[INFO] fetching crate pi_assets 0.13.4...
[INFO] checking pi_assets-0.13.4 against master#158f00a1c5175648af6f6099b075f78d1d014a28 for pr-121251
[INFO] extracting crate pi_assets 0.13.4 into /workspace/builds/worker-4-tc1/source
[INFO] validating manifest of crates.io crate pi_assets 0.13.4 on toolchain 158f00a1c5175648af6f6099b075f78d1d014a28
[INFO] running `Command { std: CARGO_HOME="/workspace/cargo-home" RUSTUP_HOME="/workspace/rustup-home" "/workspace/cargo-home/bin/cargo" "+158f00a1c5175648af6f6099b075f78d1d014a28" "metadata" "--manifest-path" "Cargo.toml" "--no-deps", kill_on_drop: false }`
[INFO] started tweaking crates.io crate pi_assets 0.13.4
[INFO] finished tweaking crates.io crate pi_assets 0.13.4
[INFO] tweaked toml for crates.io crate pi_assets 0.13.4 written to /workspace/builds/worker-4-tc1/source/Cargo.toml
[INFO] running `Command { std: CARGO_HOME="/workspace/cargo-home" RUSTUP_HOME="/workspace/rustup-home" "/workspace/cargo-home/bin/cargo" "+158f00a1c5175648af6f6099b075f78d1d014a28" "generate-lockfile" "--manifest-path" "Cargo.toml", kill_on_drop: false }`
[INFO] [stderr]     Updating crates.io index
[INFO] running `Command { std: CARGO_HOME="/workspace/cargo-home" RUSTUP_HOME="/workspace/rustup-home" "/workspace/cargo-home/bin/cargo" "+158f00a1c5175648af6f6099b075f78d1d014a28" "fetch" "--manifest-path" "Cargo.toml", kill_on_drop: false }`
[INFO] [stderr]  Downloading crates ...
[INFO] [stderr]   Downloaded pi_wheel v0.1.0
[INFO] [stderr]   Downloaded pi_slot_deque v0.2.1
[INFO] [stderr]   Downloaded pi_cancel_timer v0.2.0
[INFO] [stderr]   Downloaded pi_ext_heap v0.1.1
[INFO] [stderr]   Downloaded pi_wrr v0.1.1
[INFO] [stderr]   Downloaded pi_hash v0.1.1
[INFO] [stderr]   Downloaded pi_timer v0.1.0
[INFO] [stderr]   Downloaded pi-async-rt v0.1.18
[INFO] [stderr]   Downloaded st3 v0.4.1
[INFO] [stderr]   Downloaded pi_futures v0.1.0
[INFO] [stderr]   Downloaded pi_slot_wheel v0.2.0
[INFO] [stderr]   Downloaded probabilistic-collections v0.7.0
[INFO] [stderr]   Downloaded pi_cache v0.3.2
[INFO] [stderr]   Downloaded pi_share v0.4.15
[INFO] [stderr]   Downloaded pcg_rand v0.13.0
[INFO] [stderr]   Downloaded pi_time v0.3.4
[INFO] [stderr]   Downloaded pi_print_any v0.1.2
[INFO] running `Command { std: "docker" "create" "-v" "/var/lib/crater-agent-workspace/builds/worker-4-tc1/target:/opt/rustwide/target:rw,Z" "-v" "/var/lib/crater-agent-workspace/builds/worker-4-tc1/source:/opt/rustwide/workdir:ro,Z" "-v" "/var/lib/crater-agent-workspace/cargo-home:/opt/rustwide/cargo-home:ro,Z" "-v" "/var/lib/crater-agent-workspace/rustup-home:/opt/rustwide/rustup-home:ro,Z" "-e" "SOURCE_DIR=/opt/rustwide/workdir" "-e" "CARGO_TARGET_DIR=/opt/rustwide/target" "-e" "CARGO_HOME=/opt/rustwide/cargo-home" "-e" "RUSTUP_HOME=/opt/rustwide/rustup-home" "-w" "/opt/rustwide/workdir" "-m" "1610612736" "--user" "0:0" "--network" "none" "ghcr.io/rust-lang/crates-build-env/linux@sha256:2788e3201cd34a07e3172128adcd8b3090168a8e3bcc40d7c032b9dda1df7d1c" "/opt/rustwide/cargo-home/bin/cargo" "+158f00a1c5175648af6f6099b075f78d1d014a28" "metadata" "--no-deps" "--format-version=1", kill_on_drop: false }`
[INFO] [stdout] 50136a5996230ca03b6cf068702a9c68323ec103d8e6727510426c5b5726394f
[INFO] running `Command { std: "docker" "start" "-a" "50136a5996230ca03b6cf068702a9c68323ec103d8e6727510426c5b5726394f", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "inspect" "50136a5996230ca03b6cf068702a9c68323ec103d8e6727510426c5b5726394f", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "rm" "-f" "50136a5996230ca03b6cf068702a9c68323ec103d8e6727510426c5b5726394f", kill_on_drop: false }`
[INFO] [stdout] 50136a5996230ca03b6cf068702a9c68323ec103d8e6727510426c5b5726394f
[INFO] running `Command { std: "docker" "create" "-v" "/var/lib/crater-agent-workspace/builds/worker-4-tc1/target:/opt/rustwide/target:rw,Z" "-v" "/var/lib/crater-agent-workspace/builds/worker-4-tc1/source:/opt/rustwide/workdir:ro,Z" "-v" "/var/lib/crater-agent-workspace/cargo-home:/opt/rustwide/cargo-home:ro,Z" "-v" "/var/lib/crater-agent-workspace/rustup-home:/opt/rustwide/rustup-home:ro,Z" "-e" "SOURCE_DIR=/opt/rustwide/workdir" "-e" "CARGO_TARGET_DIR=/opt/rustwide/target" "-e" "CARGO_INCREMENTAL=0" "-e" "RUST_BACKTRACE=full" "-e" "RUSTFLAGS=--cap-lints=forbid" "-e" "RUSTDOCFLAGS=--cap-lints=forbid" "-e" "CARGO_HOME=/opt/rustwide/cargo-home" "-e" "RUSTUP_HOME=/opt/rustwide/rustup-home" "-w" "/opt/rustwide/workdir" "-m" "1610612736" "--user" "0:0" "--network" "none" "ghcr.io/rust-lang/crates-build-env/linux@sha256:2788e3201cd34a07e3172128adcd8b3090168a8e3bcc40d7c032b9dda1df7d1c" "/opt/rustwide/cargo-home/bin/cargo" "+158f00a1c5175648af6f6099b075f78d1d014a28" "check" "--frozen" "--all" "--all-targets" "--message-format=json", kill_on_drop: false }`
[INFO] [stdout] 0a4ab7197e7f3893f852e45994af7bb0d3bab4bb76a3e35b673d9e51d79ce63c
[INFO] running `Command { std: "docker" "start" "-a" "0a4ab7197e7f3893f852e45994af7bb0d3bab4bb76a3e35b673d9e51d79ce63c", kill_on_drop: false }`
[INFO] [stderr]     Checking getrandom v0.2.12
[INFO] [stderr]    Compiling crossbeam-utils v0.8.19
[INFO] [stderr]    Compiling slotmap v1.0.7
[INFO] [stderr]     Checking futures-sink v0.3.30
[INFO] [stderr]     Checking memchr v2.7.1
[INFO] [stderr]    Compiling futures-macro v0.3.30
[INFO] [stderr]    Compiling parking_lot_core v0.9.9
[INFO] [stderr]     Checking futures-io v0.3.30
[INFO] [stderr]     Checking futures-channel v0.3.30
[INFO] [stderr]     Checking static_assertions v1.1.0
[INFO] [stderr]     Checking futures-task v0.3.30
[INFO] [stderr]     Checking rand_core v0.6.4
[INFO] [stderr]    Compiling backtrace v0.3.69
[INFO] [stderr]     Checking nanorand v0.7.0
[INFO] [stderr]     Checking rand_chacha v0.3.1
[INFO] [stderr]     Checking fxhash v0.2.1
[INFO] [stderr]     Checking pi_ext_heap v0.1.1
[INFO] [stderr]     Checking gimli v0.28.1
[INFO] [stderr]     Checking miniz_oxide v0.7.2
[INFO] [stderr]     Checking rand v0.8.5
[INFO] [stderr]     Checking object v0.32.2
[INFO] [stderr]     Checking raw-cpuid v11.0.1
[INFO] [stderr]     Checking crossbeam-epoch v0.9.18
[INFO] [stderr]     Checking bincode v1.3.3
[INFO] [stderr]     Checking pi_slot_deque v0.2.1
[INFO] [stderr]     Checking pi_slot_wheel v0.2.0
[INFO] [stderr]    Compiling async-stream-impl v0.3.5
[INFO] [stderr]    Compiling pin-project-internal v1.1.4
[INFO] [stderr]     Checking rand_xorshift v0.2.0
[INFO] [stderr]     Checking twox-hash v1.6.3
[INFO] [stderr]     Checking rustc-demangle v0.1.23
[INFO] [stderr]     Checking pi_hash v0.1.1
[INFO] [stderr]     Checking pi_wheel v0.1.0
[INFO] [stderr]     Checking probabilistic-collections v0.7.0
[INFO] [stderr]     Checking futures-util v0.3.30
[INFO] [stderr]     Checking pi_timer v0.1.0
[INFO] [stderr]     Checking pi_cancel_timer v0.2.0
[INFO] [stderr]     Checking crossbeam-deque v0.8.5
[INFO] [stderr]     Checking parking_lot v0.12.1
[INFO] [stderr]     Checking st3 v0.4.1
[INFO] [stderr]     Checking async-stream v0.3.5
[INFO] [stderr]     Checking crossbeam-queue v0.3.11
[INFO] [stderr]     Checking quanta v0.12.2
[INFO] [stderr]     Checking crossbeam-channel v0.5.12
[INFO] [stderr]     Checking flume v0.11.0
[INFO] [stderr]    Compiling ctor v0.2.7
[INFO] [stderr]     Checking num_cpus v1.16.0
[INFO] [stderr]     Checking pi_print_any v0.1.2
[INFO] [stderr]     Checking pi_wrr v0.1.1
[INFO] [stderr]     Checking pi_cache v0.3.2
[INFO] [stderr]     Checking pi_futures v0.1.0
[INFO] [stderr]     Checking pi_share v0.4.15
[INFO] [stderr]     Checking pcg_rand v0.13.0
[INFO] [stderr]     Checking addr2line v0.21.0
[INFO] [stderr]     Checking pi_time v0.3.4
[INFO] [stderr]     Checking pin-project v1.1.4
[INFO] [stderr]     Checking flume v0.10.14
[INFO] [stderr]     Checking futures-executor v0.3.30
[INFO] [stderr]     Checking futures v0.3.30
[INFO] [stderr]     Checking pi-async-rt v0.1.18
[INFO] [stderr]     Checking pi_assets v0.13.4 (/opt/rustwide/workdir)
[INFO] [stdout] error[E0615]: attempted to take value of method `map` on type `Result<std::sync::MutexGuard<'_, asset::AssetTable<A>>, PoisonError<std::sync::MutexGuard<'_, asset::AssetTable<A>>>>`
[INFO] [stdout]   --> src/asset.rs:92:15
[INFO] [stdout]    |
[INFO] [stdout] 92 |         table.map.remove(&self.key);
[INFO] [stdout]    |               ^^^ method, not a field
[INFO] [stdout]    |
[INFO] [stdout] help: use parentheses to call the method
[INFO] [stdout]    |
[INFO] [stdout] 92 |         table.map(_).remove(&self.key);
[INFO] [stdout]    |                  +++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0609]: no field `timeout` on type `Result<std::sync::MutexGuard<'_, asset::AssetTable<A>>, PoisonError<std::sync::MutexGuard<'_, asset::AssetTable<A>>>>`
[INFO] [stdout]   --> src/asset.rs:93:29
[INFO] [stdout]    |
[INFO] [stdout] 93 |         let timeout = table.timeout as u64 + now_millisecond();
[INFO] [stdout]    |                             ^^^^^^^ unknown field
[INFO] [stdout]    |
[INFO] [stdout] help: one of the expressions' fields has a field of the same name
[INFO] [stdout]    |
[INFO] [stdout] 93 |         let timeout = table.unwrap().timeout as u64 + now_millisecond();
[INFO] [stdout]    |                             +++++++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0609]: no field `cache` on type `Result<std::sync::MutexGuard<'_, asset::AssetTable<A>>, PoisonError<std::sync::MutexGuard<'_, asset::AssetTable<A>>>>`
[INFO] [stdout]   --> src/asset.rs:94:15
[INFO] [stdout]    |
[INFO] [stdout] 94 |         table.cache.put(self.key.clone(), Item(v, timeout));
[INFO] [stdout]    |               ^^^^^ unknown field
[INFO] [stdout]    |
[INFO] [stdout] help: one of the expressions' fields has a field of the same name
[INFO] [stdout]    |
[INFO] [stdout] 94 |         table.unwrap().cache.put(self.key.clone(), Item(v, timeout));
[INFO] [stdout]    |               +++++++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0609]: no field `cache` on type `Result<std::sync::MutexGuard<'_, asset::AssetTable<T>>, PoisonError<std::sync::MutexGuard<'_, asset::AssetTable<T>>>>`
[INFO] [stdout]    --> src/asset.rs:109:15
[INFO] [stdout]     |
[INFO] [stdout] 109 |         table.cache.collect(self.key.clone());
[INFO] [stdout]     |               ^^^^^ unknown field
[INFO] [stdout]     |
[INFO] [stdout] help: one of the expressions' fields has a field of the same name
[INFO] [stdout]     |
[INFO] [stdout] 109 |         table.unwrap().cache.collect(self.key.clone());
[INFO] [stdout]     |               +++++++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0615]: attempted to take value of method `map` on type `Result<std::sync::MutexGuard<'_, asset::AssetTable<A>>, PoisonError<std::sync::MutexGuard<'_, asset::AssetTable<A>>>>`
[INFO] [stdout]   --> src/asset.rs:92:15
[INFO] [stdout]    |
[INFO] [stdout] 92 |         table.map.remove(&self.key);
[INFO] [stdout]    |               ^^^ method, not a field
[INFO] [stdout]    |
[INFO] [stdout] help: use parentheses to call the method
[INFO] [stdout]    |
[INFO] [stdout] 92 |         table.map(_).remove(&self.key);
[INFO] [stdout]    |                  +++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0609]: no field `timeout` on type `Result<std::sync::MutexGuard<'_, asset::AssetTable<A>>, PoisonError<std::sync::MutexGuard<'_, asset::AssetTable<A>>>>`
[INFO] [stdout]    --> src/mgr.rs:141:28
[INFO] [stdout]     |
[INFO] [stdout] 141 |             timeout: table.timeout,
[INFO] [stdout]     |                            ^^^^^^^ unknown field
[INFO] [stdout]     |
[INFO] [stdout] help: one of the expressions' fields has a field of the same name
[INFO] [stdout]     |
[INFO] [stdout] 141 |             timeout: table.unwrap().timeout,
[INFO] [stdout]     |                            +++++++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0609]: no field `timeout` on type `Result<std::sync::MutexGuard<'_, asset::AssetTable<A>>, PoisonError<std::sync::MutexGuard<'_, asset::AssetTable<A>>>>`
[INFO] [stdout]   --> src/asset.rs:93:29
[INFO] [stdout]    |
[INFO] [stdout] 93 |         let timeout = table.timeout as u64 + now_millisecond();
[INFO] [stdout]    |                             ^^^^^^^ unknown field
[INFO] [stdout]    |
[INFO] [stdout] help: one of the expressions' fields has a field of the same name
[INFO] [stdout]    |
[INFO] [stdout] 93 |         let timeout = table.unwrap().timeout as u64 + now_millisecond();
[INFO] [stdout]    |                             +++++++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0609]: no field `cache` on type `Result<std::sync::MutexGuard<'_, asset::AssetTable<A>>, PoisonError<std::sync::MutexGuard<'_, asset::AssetTable<A>>>>`
[INFO] [stdout]   --> src/asset.rs:94:15
[INFO] [stdout]    |
[INFO] [stdout] 94 |         table.cache.put(self.key.clone(), Item(v, timeout));
[INFO] [stdout]    |               ^^^^^ unknown field
[INFO] [stdout]    |
[INFO] [stdout] help: one of the expressions' fields has a field of the same name
[INFO] [stdout]    |
[INFO] [stdout] 94 |         table.unwrap().cache.put(self.key.clone(), Item(v, timeout));
[INFO] [stdout]    |               +++++++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0609]: no field `cache` on type `Result<std::sync::MutexGuard<'_, asset::AssetTable<T>>, PoisonError<std::sync::MutexGuard<'_, asset::AssetTable<T>>>>`
[INFO] [stdout]    --> src/asset.rs:109:15
[INFO] [stdout]     |
[INFO] [stdout] 109 |         table.cache.collect(self.key.clone());
[INFO] [stdout]     |               ^^^^^ unknown field
[INFO] [stdout]     |
[INFO] [stdout] help: one of the expressions' fields has a field of the same name
[INFO] [stdout]     |
[INFO] [stdout] 109 |         table.unwrap().cache.collect(self.key.clone());
[INFO] [stdout]     |               +++++++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0609]: no field `timeout` on type `Result<std::sync::MutexGuard<'_, asset::AssetTable<A>>, PoisonError<std::sync::MutexGuard<'_, asset::AssetTable<A>>>>`
[INFO] [stdout]    --> src/mgr.rs:141:28
[INFO] [stdout]     |
[INFO] [stdout] 141 |             timeout: table.timeout,
[INFO] [stdout]     |                            ^^^^^^^ unknown field
[INFO] [stdout]     |
[INFO] [stdout] help: one of the expressions' fields has a field of the same name
[INFO] [stdout]     |
[INFO] [stdout] 141 |             timeout: table.unwrap().timeout,
[INFO] [stdout]     |                            +++++++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0599]: no method named `cache_len` found for enum `Result` in the current scope
[INFO] [stdout]    --> src/mgr.rs:145:30
[INFO] [stdout]     |
[INFO] [stdout] 145 |             cache_len: table.cache_len(),
[INFO] [stdout]     |                              ^^^^^^^^^ method not found in `Result<MutexGuard<'_, AssetTable<A>>, PoisonError<MutexGuard<'_, AssetTable<A>>>>`
[INFO] [stdout]     |
[INFO] [stdout] note: the method `cache_len` exists on the type `std::sync::MutexGuard<'_, asset::AssetTable<A>>`
[INFO] [stdout]    --> src/asset.rs:158:5
[INFO] [stdout]     |
[INFO] [stdout] 158 |     pub fn cache_len(&self) -> usize {
[INFO] [stdout]     |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] help: consider using `Result::expect` to unwrap the `std::sync::MutexGuard<'_, asset::AssetTable<A>>` value, panicking if the value is a `Result::Err`
[INFO] [stdout]     |
[INFO] [stdout] 145 |             cache_len: table.expect("REASON").cache_len(),
[INFO] [stdout]     |                             +++++++++++++++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0599]: no method named `cache_size` found for enum `Result` in the current scope
[INFO] [stdout]    --> src/mgr.rs:146:31
[INFO] [stdout]     |
[INFO] [stdout] 146 |             cache_size: table.cache_size(),
[INFO] [stdout]     |                               ^^^^^^^^^^ method not found in `Result<MutexGuard<'_, AssetTable<A>>, PoisonError<MutexGuard<'_, AssetTable<A>>>>`
[INFO] [stdout]     |
[INFO] [stdout] note: the method `cache_size` exists on the type `std::sync::MutexGuard<'_, asset::AssetTable<A>>`
[INFO] [stdout]    --> src/asset.rs:150:5
[INFO] [stdout]     |
[INFO] [stdout] 150 |     pub fn cache_size(&self) -> usize {
[INFO] [stdout]     |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] help: consider using `Result::expect` to unwrap the `std::sync::MutexGuard<'_, asset::AssetTable<A>>` value, panicking if the value is a `Result::Err`
[INFO] [stdout]     |
[INFO] [stdout] 146 |             cache_size: table.expect("REASON").cache_size(),
[INFO] [stdout]     |                              +++++++++++++++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0599]: no method named `cache_len` found for enum `Result` in the current scope
[INFO] [stdout]    --> src/mgr.rs:145:30
[INFO] [stdout]     |
[INFO] [stdout] 145 |             cache_len: table.cache_len(),
[INFO] [stdout]     |                              ^^^^^^^^^ method not found in `Result<MutexGuard<'_, AssetTable<A>>, PoisonError<MutexGuard<'_, AssetTable<A>>>>`
[INFO] [stdout]     |
[INFO] [stdout] note: the method `cache_len` exists on the type `std::sync::MutexGuard<'_, asset::AssetTable<A>>`
[INFO] [stdout]    --> src/asset.rs:158:5
[INFO] [stdout]     |
[INFO] [stdout] 158 |     pub fn cache_len(&self) -> usize {
[INFO] [stdout]     |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] help: consider using `Result::expect` to unwrap the `std::sync::MutexGuard<'_, asset::AssetTable<A>>` value, panicking if the value is a `Result::Err`
[INFO] [stdout]     |
[INFO] [stdout] 145 |             cache_len: table.expect("REASON").cache_len(),
[INFO] [stdout]     |                             +++++++++++++++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0599]: no method named `cache_metrics` found for enum `Result` in the current scope
[INFO] [stdout]    --> src/mgr.rs:147:34
[INFO] [stdout]     |
[INFO] [stdout] 147 |             cache_metrics: table.cache_metrics(),
[INFO] [stdout]     |                                  ^^^^^^^^^^^^^ method not found in `Result<MutexGuard<'_, AssetTable<A>>, PoisonError<MutexGuard<'_, AssetTable<A>>>>`
[INFO] [stdout]     |
[INFO] [stdout] note: the method `cache_metrics` exists on the type `std::sync::MutexGuard<'_, asset::AssetTable<A>>`
[INFO] [stdout]    --> src/asset.rs:154:5
[INFO] [stdout]     |
[INFO] [stdout] 154 |     pub fn cache_metrics(&self) -> Metrics {
[INFO] [stdout]     |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] help: consider using `Result::expect` to unwrap the `std::sync::MutexGuard<'_, asset::AssetTable<A>>` value, panicking if the value is a `Result::Err`
[INFO] [stdout]     |
[INFO] [stdout] 147 |             cache_metrics: table.expect("REASON").cache_metrics(),
[INFO] [stdout]     |                                 +++++++++++++++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0599]: no method named `cache_size` found for enum `Result` in the current scope
[INFO] [stdout]    --> src/mgr.rs:146:31
[INFO] [stdout]     |
[INFO] [stdout] 146 |             cache_size: table.cache_size(),
[INFO] [stdout]     |                               ^^^^^^^^^^ method not found in `Result<MutexGuard<'_, AssetTable<A>>, PoisonError<MutexGuard<'_, AssetTable<A>>>>`
[INFO] [stdout]     |
[INFO] [stdout] note: the method `cache_size` exists on the type `std::sync::MutexGuard<'_, asset::AssetTable<A>>`
[INFO] [stdout]    --> src/asset.rs:150:5
[INFO] [stdout]     |
[INFO] [stdout] 150 |     pub fn cache_size(&self) -> usize {
[INFO] [stdout]     |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] help: consider using `Result::expect` to unwrap the `std::sync::MutexGuard<'_, asset::AssetTable<A>>` value, panicking if the value is a `Result::Err`
[INFO] [stdout]     |
[INFO] [stdout] 146 |             cache_size: table.expect("REASON").cache_size(),
[INFO] [stdout]     |                              +++++++++++++++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0599]: no method named `contains_key` found for enum `Result` in the current scope
[INFO] [stdout]    --> src/mgr.rs:153:15
[INFO] [stdout]     |
[INFO] [stdout] 153 |         table.contains_key(k)
[INFO] [stdout]     |               ^^^^^^^^^^^^ method not found in `Result<MutexGuard<'_, AssetTable<A>>, PoisonError<MutexGuard<'_, AssetTable<A>>>>`
[INFO] [stdout]     |
[INFO] [stdout] note: the method `contains_key` exists on the type `std::sync::MutexGuard<'_, asset::AssetTable<A>>`
[INFO] [stdout]    --> src/asset.rs:162:5
[INFO] [stdout]     |
[INFO] [stdout] 162 |     pub fn contains_key(&self, k: &A::Key) -> bool {
[INFO] [stdout]     |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] help: consider using `Result::expect` to unwrap the `std::sync::MutexGuard<'_, asset::AssetTable<A>>` value, panicking if the value is a `Result::Err`
[INFO] [stdout]     |
[INFO] [stdout] 153 |         table.expect("REASON").contains_key(k)
[INFO] [stdout]     |              +++++++++++++++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0599]: no method named `cache_metrics` found for enum `Result` in the current scope
[INFO] [stdout]    --> src/mgr.rs:147:34
[INFO] [stdout]     |
[INFO] [stdout] 147 |             cache_metrics: table.cache_metrics(),
[INFO] [stdout]     |                                  ^^^^^^^^^^^^^ method not found in `Result<MutexGuard<'_, AssetTable<A>>, PoisonError<MutexGuard<'_, AssetTable<A>>>>`
[INFO] [stdout]     |
[INFO] [stdout] note: the method `cache_metrics` exists on the type `std::sync::MutexGuard<'_, asset::AssetTable<A>>`
[INFO] [stdout]    --> src/asset.rs:154:5
[INFO] [stdout]     |
[INFO] [stdout] 154 |     pub fn cache_metrics(&self) -> Metrics {
[INFO] [stdout]     |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] help: consider using `Result::expect` to unwrap the `std::sync::MutexGuard<'_, asset::AssetTable<A>>` value, panicking if the value is a `Result::Err`
[INFO] [stdout]     |
[INFO] [stdout] 147 |             cache_metrics: table.expect("REASON").cache_metrics(),
[INFO] [stdout]     |                                 +++++++++++++++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0599]: no method named `cache` found for enum `Result` in the current scope
[INFO] [stdout]    --> src/mgr.rs:160:27
[INFO] [stdout]     |
[INFO] [stdout] 160 |             let r = table.cache(k, v);
[INFO] [stdout]     |                           ^^^^^ method not found in `Result<MutexGuard<'_, AssetTable<A>>, PoisonError<MutexGuard<'_, AssetTable<A>>>>`
[INFO] [stdout]     |
[INFO] [stdout] note: the method `cache` exists on the type `std::sync::MutexGuard<'_, asset::AssetTable<A>>`
[INFO] [stdout]    --> src/asset.rs:174:5
[INFO] [stdout]     |
[INFO] [stdout] 174 |     pub fn cache(&mut self, k: A::Key, v: A) -> Option<A> {
[INFO] [stdout]     |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] help: consider using `Result::expect` to unwrap the `std::sync::MutexGuard<'_, asset::AssetTable<A>>` value, panicking if the value is a `Result::Err`
[INFO] [stdout]     |
[INFO] [stdout] 160 |             let r = table.expect("REASON").cache(k, v);
[INFO] [stdout]     |                          +++++++++++++++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0599]: no method named `contains_key` found for enum `Result` in the current scope
[INFO] [stdout]    --> src/mgr.rs:153:15
[INFO] [stdout]     |
[INFO] [stdout] 153 |         table.contains_key(k)
[INFO] [stdout]     |               ^^^^^^^^^^^^ method not found in `Result<MutexGuard<'_, AssetTable<A>>, PoisonError<MutexGuard<'_, AssetTable<A>>>>`
[INFO] [stdout]     |
[INFO] [stdout] note: the method `contains_key` exists on the type `std::sync::MutexGuard<'_, asset::AssetTable<A>>`
[INFO] [stdout]    --> src/asset.rs:162:5
[INFO] [stdout]     |
[INFO] [stdout] 162 |     pub fn contains_key(&self, k: &A::Key) -> bool {
[INFO] [stdout]     |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] help: consider using `Result::expect` to unwrap the `std::sync::MutexGuard<'_, asset::AssetTable<A>>` value, panicking if the value is a `Result::Err`
[INFO] [stdout]     |
[INFO] [stdout] 153 |         table.expect("REASON").contains_key(k)
[INFO] [stdout]     |              +++++++++++++++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0599]: no method named `cache_size` found for enum `Result` in the current scope
[INFO] [stdout]    --> src/mgr.rs:171:46
[INFO] [stdout]     |
[INFO] [stdout] 171 |                     let t = capacity + table.cache_size();
[INFO] [stdout]     |                                              ^^^^^^^^^^ method not found in `Result<MutexGuard<'_, AssetTable<A>>, PoisonError<MutexGuard<'_, AssetTable<A>>>>`
[INFO] [stdout]     |
[INFO] [stdout] note: the method `cache_size` exists on the type `std::sync::MutexGuard<'_, asset::AssetTable<A>>`
[INFO] [stdout]    --> src/asset.rs:150:5
[INFO] [stdout]     |
[INFO] [stdout] 150 |     pub fn cache_size(&self) -> usize {
[INFO] [stdout]     |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] help: consider using `Result::expect` to unwrap the `std::sync::MutexGuard<'_, asset::AssetTable<A>>` value, panicking if the value is a `Result::Err`
[INFO] [stdout]     |
[INFO] [stdout] 171 |                     let t = capacity + table.expect("REASON").cache_size();
[INFO] [stdout]     |                                             +++++++++++++++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0599]: no method named `cache` found for enum `Result` in the current scope
[INFO] [stdout]    --> src/mgr.rs:160:27
[INFO] [stdout]     |
[INFO] [stdout] 160 |             let r = table.cache(k, v);
[INFO] [stdout]     |                           ^^^^^ method not found in `Result<MutexGuard<'_, AssetTable<A>>, PoisonError<MutexGuard<'_, AssetTable<A>>>>`
[INFO] [stdout]     |
[INFO] [stdout] note: the method `cache` exists on the type `std::sync::MutexGuard<'_, asset::AssetTable<A>>`
[INFO] [stdout]    --> src/asset.rs:174:5
[INFO] [stdout]     |
[INFO] [stdout] 174 |     pub fn cache(&mut self, k: A::Key, v: A) -> Option<A> {
[INFO] [stdout]     |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] help: consider using `Result::expect` to unwrap the `std::sync::MutexGuard<'_, asset::AssetTable<A>>` value, panicking if the value is a `Result::Err`
[INFO] [stdout]     |
[INFO] [stdout] 160 |             let r = table.expect("REASON").cache(k, v);
[INFO] [stdout]     |                          +++++++++++++++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0599]: no method named `capacity_collect` found for enum `Result` in the current scope
[INFO] [stdout]    --> src/mgr.rs:174:40
[INFO] [stdout]     |
[INFO] [stdout] 174 |                     let (l, s) = table.capacity_collect(&self.garbage, c, self.ref_garbage_lock);
[INFO] [stdout]     |                                        ^^^^^^^^^^^^^^^^ method not found in `Result<MutexGuard<'_, AssetTable<A>>, PoisonError<MutexGuard<'_, AssetTable<A>>>>`
[INFO] [stdout]     |
[INFO] [stdout] note: the method `capacity_collect` exists on the type `std::sync::MutexGuard<'_, asset::AssetTable<A>>`
[INFO] [stdout]    --> src/asset.rs:316:5
[INFO] [stdout]     |
[INFO] [stdout] 316 | /     pub fn capacity_collect<G: Garbageer<A>>(
[INFO] [stdout] 317 | |         &mut self,
[INFO] [stdout] 318 | |         g: &G,
[INFO] [stdout] 319 | |         capacity: usize,
[INFO] [stdout] 320 | |         lock: usize,
[INFO] [stdout] 321 | |     ) -> (usize, usize) {
[INFO] [stdout]     | |_______________________^
[INFO] [stdout]     = help: items from traits can only be used if the trait is implemented and in scope
[INFO] [stdout] note: `allocator::Collect` defines an item `capacity_collect`, perhaps you need to implement it
[INFO] [stdout]    --> src/allocator.rs:12:1
[INFO] [stdout]     |
[INFO] [stdout] 12  | pub trait Collect: Send + Sync {
[INFO] [stdout]     | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] help: consider using `Result::expect` to unwrap the `std::sync::MutexGuard<'_, asset::AssetTable<A>>` value, panicking if the value is a `Result::Err`
[INFO] [stdout]     |
[INFO] [stdout] 174 |                     let (l, s) = table.expect("REASON").capacity_collect(&self.garbage, c, self.ref_garbage_lock);
[INFO] [stdout]     |                                       +++++++++++++++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0599]: no method named `cache_size` found for enum `Result` in the current scope
[INFO] [stdout]    --> src/mgr.rs:171:46
[INFO] [stdout]     |
[INFO] [stdout] 171 |                     let t = capacity + table.cache_size();
[INFO] [stdout]     |                                              ^^^^^^^^^^ method not found in `Result<MutexGuard<'_, AssetTable<A>>, PoisonError<MutexGuard<'_, AssetTable<A>>>>`
[INFO] [stdout]     |
[INFO] [stdout] note: the method `cache_size` exists on the type `std::sync::MutexGuard<'_, asset::AssetTable<A>>`
[INFO] [stdout]    --> src/asset.rs:150:5
[INFO] [stdout]     |
[INFO] [stdout] 150 |     pub fn cache_size(&self) -> usize {
[INFO] [stdout]     |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] help: consider using `Result::expect` to unwrap the `std::sync::MutexGuard<'_, asset::AssetTable<A>>` value, panicking if the value is a `Result::Err`
[INFO] [stdout]     |
[INFO] [stdout] 171 |                     let t = capacity + table.expect("REASON").cache_size();
[INFO] [stdout]     |                                             +++++++++++++++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0599]: no method named `insert` found for enum `Result` in the current scope
[INFO] [stdout]    --> src/mgr.rs:194:32
[INFO] [stdout]     |
[INFO] [stdout] 194 |             let (r, b) = table.insert(k.clone(), v, lock);
[INFO] [stdout]     |                                ^^^^^^
[INFO] [stdout]     |
[INFO] [stdout] note: the method `insert` exists on the type `std::sync::MutexGuard<'_, asset::AssetTable<A>>`
[INFO] [stdout]    --> src/asset.rs:180:5
[INFO] [stdout]     |
[INFO] [stdout] 180 |     pub fn insert(&mut self, k: A::Key, v: A, lock: usize) -> (Result1<Handle<A>, A>, bool) {
[INFO] [stdout]     |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] help: use the `?` operator to extract the `std::sync::MutexGuard<'_, asset::AssetTable<A>>` value, propagating a `Result::Err` value to the caller
[INFO] [stdout]     |
[INFO] [stdout] 194 |             let (r, b) = table?.insert(k.clone(), v, lock);
[INFO] [stdout]     |                               +
[INFO] [stdout] help: there is a method with a similar name
[INFO] [stdout]     |
[INFO] [stdout] 194 |             let (r, b) = table.inspect(k.clone(), v, lock);
[INFO] [stdout]     |                                ~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0599]: no method named `capacity_collect` found for enum `Result` in the current scope
[INFO] [stdout]    --> src/mgr.rs:174:40
[INFO] [stdout]     |
[INFO] [stdout] 174 |                     let (l, s) = table.capacity_collect(&self.garbage, c, self.ref_garbage_lock);
[INFO] [stdout]     |                                        ^^^^^^^^^^^^^^^^ method not found in `Result<MutexGuard<'_, AssetTable<A>>, PoisonError<MutexGuard<'_, AssetTable<A>>>>`
[INFO] [stdout]     |
[INFO] [stdout] note: the method `capacity_collect` exists on the type `std::sync::MutexGuard<'_, asset::AssetTable<A>>`
[INFO] [stdout]    --> src/asset.rs:316:5
[INFO] [stdout]     |
[INFO] [stdout] 316 | /     pub fn capacity_collect<G: Garbageer<A>>(
[INFO] [stdout] 317 | |         &mut self,
[INFO] [stdout] 318 | |         g: &G,
[INFO] [stdout] 319 | |         capacity: usize,
[INFO] [stdout] 320 | |         lock: usize,
[INFO] [stdout] 321 | |     ) -> (usize, usize) {
[INFO] [stdout]     | |_______________________^
[INFO] [stdout]     = help: items from traits can only be used if the trait is implemented and in scope
[INFO] [stdout] note: `allocator::Collect` defines an item `capacity_collect`, perhaps you need to implement it
[INFO] [stdout]    --> src/allocator.rs:12:1
[INFO] [stdout]     |
[INFO] [stdout] 12  | pub trait Collect: Send + Sync {
[INFO] [stdout]     | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] help: consider using `Result::expect` to unwrap the `std::sync::MutexGuard<'_, asset::AssetTable<A>>` value, panicking if the value is a `Result::Err`
[INFO] [stdout]     |
[INFO] [stdout] 174 |                     let (l, s) = table.expect("REASON").capacity_collect(&self.garbage, c, self.ref_garbage_lock);
[INFO] [stdout]     |                                       +++++++++++++++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0599]: no method named `cache_size` found for enum `Result` in the current scope
[INFO] [stdout]    --> src/mgr.rs:217:42
[INFO] [stdout]     |
[INFO] [stdout] 217 |                 let t = capacity + table.cache_size();
[INFO] [stdout]     |                                          ^^^^^^^^^^ method not found in `Result<MutexGuard<'_, AssetTable<A>>, PoisonError<MutexGuard<'_, AssetTable<A>>>>`
[INFO] [stdout]     |
[INFO] [stdout] note: the method `cache_size` exists on the type `std::sync::MutexGuard<'_, asset::AssetTable<A>>`
[INFO] [stdout]    --> src/asset.rs:150:5
[INFO] [stdout]     |
[INFO] [stdout] 150 |     pub fn cache_size(&self) -> usize {
[INFO] [stdout]     |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] help: use the `?` operator to extract the `std::sync::MutexGuard<'_, asset::AssetTable<A>>` value, propagating a `Result::Err` value to the caller
[INFO] [stdout]     |
[INFO] [stdout] 217 |                 let t = capacity + table?.cache_size();
[INFO] [stdout]     |                                         +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0599]: no method named `capacity_collect` found for enum `Result` in the current scope
[INFO] [stdout]    --> src/mgr.rs:220:23
[INFO] [stdout]     |
[INFO] [stdout] 220 |                 table.capacity_collect(&self.garbage, c, self.ref_garbage_lock)
[INFO] [stdout]     |                       ^^^^^^^^^^^^^^^^ method not found in `Result<MutexGuard<'_, AssetTable<A>>, PoisonError<MutexGuard<'_, AssetTable<A>>>>`
[INFO] [stdout]     |
[INFO] [stdout] note: the method `capacity_collect` exists on the type `std::sync::MutexGuard<'_, asset::AssetTable<A>>`
[INFO] [stdout]    --> src/asset.rs:316:5
[INFO] [stdout]     |
[INFO] [stdout] 316 | /     pub fn capacity_collect<G: Garbageer<A>>(
[INFO] [stdout] 317 | |         &mut self,
[INFO] [stdout] 318 | |         g: &G,
[INFO] [stdout] 319 | |         capacity: usize,
[INFO] [stdout] 320 | |         lock: usize,
[INFO] [stdout] 321 | |     ) -> (usize, usize) {
[INFO] [stdout]     | |_______________________^
[INFO] [stdout]     = help: items from traits can only be used if the trait is implemented and in scope
[INFO] [stdout] note: `allocator::Collect` defines an item `capacity_collect`, perhaps you need to implement it
[INFO] [stdout]    --> src/allocator.rs:12:1
[INFO] [stdout]     |
[INFO] [stdout] 12  | pub trait Collect: Send + Sync {
[INFO] [stdout]     | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] help: use the `?` operator to extract the `std::sync::MutexGuard<'_, asset::AssetTable<A>>` value, propagating a `Result::Err` value to the caller
[INFO] [stdout]     |
[INFO] [stdout] 220 |                 table?.capacity_collect(&self.garbage, c, self.ref_garbage_lock)
[INFO] [stdout]     |                      +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0599]: no method named `insert` found for enum `Result` in the current scope
[INFO] [stdout]    --> src/mgr.rs:194:32
[INFO] [stdout]     |
[INFO] [stdout] 194 |             let (r, b) = table.insert(k.clone(), v, lock);
[INFO] [stdout]     |                                ^^^^^^
[INFO] [stdout]     |
[INFO] [stdout] note: the method `insert` exists on the type `std::sync::MutexGuard<'_, asset::AssetTable<A>>`
[INFO] [stdout]    --> src/asset.rs:180:5
[INFO] [stdout]     |
[INFO] [stdout] 180 |     pub fn insert(&mut self, k: A::Key, v: A, lock: usize) -> (Result1<Handle<A>, A>, bool) {
[INFO] [stdout]     |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] help: use the `?` operator to extract the `std::sync::MutexGuard<'_, asset::AssetTable<A>>` value, propagating a `Result::Err` value to the caller
[INFO] [stdout]     |
[INFO] [stdout] 194 |             let (r, b) = table?.insert(k.clone(), v, lock);
[INFO] [stdout]     |                               +
[INFO] [stdout] help: there is a method with a similar name
[INFO] [stdout]     |
[INFO] [stdout] 194 |             let (r, b) = table.inspect(k.clone(), v, lock);
[INFO] [stdout]     |                                ~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0599]: no method named `get` found for enum `Result` in the current scope
[INFO] [stdout]    --> src/mgr.rs:238:36
[INFO] [stdout]     |
[INFO] [stdout] 238 |             if let Some(r) = table.get(k.clone(), lock) {
[INFO] [stdout]     |                                    ^^^ method not found in `Result<MutexGuard<'_, AssetTable<A>>, PoisonError<MutexGuard<'_, AssetTable<A>>>>`
[INFO] [stdout]     |
[INFO] [stdout] note: the method `get` exists on the type `std::sync::MutexGuard<'_, asset::AssetTable<A>>`
[INFO] [stdout]    --> src/asset.rs:205:5
[INFO] [stdout]     |
[INFO] [stdout] 205 |     pub fn get(&mut self, k: A::Key, lock: usize) -> Option<Option<Handle<A>>> {
[INFO] [stdout]     |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] help: consider using `Result::expect` to unwrap the `std::sync::MutexGuard<'_, asset::AssetTable<A>>` value, panicking if the value is a `Result::Err`
[INFO] [stdout]     |
[INFO] [stdout] 238 |             if let Some(r) = table.expect("REASON").get(k.clone(), lock) {
[INFO] [stdout]     |                                   +++++++++++++++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0599]: no method named `cache_size` found for enum `Result` in the current scope
[INFO] [stdout]    --> src/mgr.rs:217:42
[INFO] [stdout]     |
[INFO] [stdout] 217 |                 let t = capacity + table.cache_size();
[INFO] [stdout]     |                                          ^^^^^^^^^^ method not found in `Result<MutexGuard<'_, AssetTable<A>>, PoisonError<MutexGuard<'_, AssetTable<A>>>>`
[INFO] [stdout]     |
[INFO] [stdout] note: the method `cache_size` exists on the type `std::sync::MutexGuard<'_, asset::AssetTable<A>>`
[INFO] [stdout]    --> src/asset.rs:150:5
[INFO] [stdout]     |
[INFO] [stdout] 150 |     pub fn cache_size(&self) -> usize {
[INFO] [stdout]     |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] help: use the `?` operator to extract the `std::sync::MutexGuard<'_, asset::AssetTable<A>>` value, propagating a `Result::Err` value to the caller
[INFO] [stdout]     |
[INFO] [stdout] 217 |                 let t = capacity + table?.cache_size();
[INFO] [stdout]     |                                         +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0599]: no method named `check` found for enum `Result` in the current scope
[INFO] [stdout]    --> src/mgr.rs:253:25
[INFO] [stdout]     |
[INFO] [stdout] 253 |             match table.check(k.clone(), lock, true) {
[INFO] [stdout]     |                         ^^^^^ method not found in `Result<MutexGuard<'_, AssetTable<A>>, PoisonError<MutexGuard<'_, AssetTable<A>>>>`
[INFO] [stdout]     |
[INFO] [stdout] note: the method `check` exists on the type `std::sync::MutexGuard<'_, asset::AssetTable<A>>`
[INFO] [stdout]    --> src/asset.rs:227:5
[INFO] [stdout]     |
[INFO] [stdout] 227 | /     pub fn check(
[INFO] [stdout] 228 | |         &mut self,
[INFO] [stdout] 229 | |         k: A::Key,
[INFO] [stdout] 230 | |         lock: usize,
[INFO] [stdout] 231 | |         wait: bool,
[INFO] [stdout] 232 | |     ) -> Result1<Option<Handle<A>>, Option<Receiver<Result<Handle<A>>>>> {
[INFO] [stdout]     | |________________________________________________________________________^
[INFO] [stdout] help: consider using `Result::expect` to unwrap the `std::sync::MutexGuard<'_, asset::AssetTable<A>>` value, panicking if the value is a `Result::Err`
[INFO] [stdout]     |
[INFO] [stdout] 253 |             match table.expect("REASON").check(k.clone(), lock, true) {
[INFO] [stdout]     |                        +++++++++++++++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0599]: no method named `capacity_collect` found for enum `Result` in the current scope
[INFO] [stdout]    --> src/mgr.rs:220:23
[INFO] [stdout]     |
[INFO] [stdout] 220 |                 table.capacity_collect(&self.garbage, c, self.ref_garbage_lock)
[INFO] [stdout]     |                       ^^^^^^^^^^^^^^^^ method not found in `Result<MutexGuard<'_, AssetTable<A>>, PoisonError<MutexGuard<'_, AssetTable<A>>>>`
[INFO] [stdout]     |
[INFO] [stdout] note: the method `capacity_collect` exists on the type `std::sync::MutexGuard<'_, asset::AssetTable<A>>`
[INFO] [stdout]    --> src/asset.rs:316:5
[INFO] [stdout]     |
[INFO] [stdout] 316 | /     pub fn capacity_collect<G: Garbageer<A>>(
[INFO] [stdout] 317 | |         &mut self,
[INFO] [stdout] 318 | |         g: &G,
[INFO] [stdout] 319 | |         capacity: usize,
[INFO] [stdout] 320 | |         lock: usize,
[INFO] [stdout] 321 | |     ) -> (usize, usize) {
[INFO] [stdout]     | |_______________________^
[INFO] [stdout]     = help: items from traits can only be used if the trait is implemented and in scope
[INFO] [stdout] note: `allocator::Collect` defines an item `capacity_collect`, perhaps you need to implement it
[INFO] [stdout]    --> src/allocator.rs:12:1
[INFO] [stdout]     |
[INFO] [stdout] 12  | pub trait Collect: Send + Sync {
[INFO] [stdout]     | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] help: use the `?` operator to extract the `std::sync::MutexGuard<'_, asset::AssetTable<A>>` value, propagating a `Result::Err` value to the caller
[INFO] [stdout]     |
[INFO] [stdout] 220 |                 table?.capacity_collect(&self.garbage, c, self.ref_garbage_lock)
[INFO] [stdout]     |                      +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0599]: no method named `cache_size` found for enum `Result` in the current scope
[INFO] [stdout]    --> src/mgr.rs:298:50
[INFO] [stdout]     |
[INFO] [stdout] 298 |                         let t = capacity + table.cache_size();
[INFO] [stdout]     |                                                  ^^^^^^^^^^ method not found in `Result<MutexGuard<'_, AssetTable<A>>, PoisonError<MutexGuard<'_, AssetTable<A>>>>`
[INFO] [stdout]     |
[INFO] [stdout] note: the method `cache_size` exists on the type `std::sync::MutexGuard<'_, asset::AssetTable<A>>`
[INFO] [stdout]    --> src/asset.rs:150:5
[INFO] [stdout]     |
[INFO] [stdout] 150 |     pub fn cache_size(&self) -> usize {
[INFO] [stdout]     |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] help: consider using `Result::expect` to unwrap the `std::sync::MutexGuard<'_, asset::AssetTable<A>>` value, panicking if the value is a `Result::Err`
[INFO] [stdout]     |
[INFO] [stdout] 298 |                         let t = capacity + table.expect("REASON").cache_size();
[INFO] [stdout]     |                                                 +++++++++++++++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0599]: no method named `get` found for enum `Result` in the current scope
[INFO] [stdout]    --> src/mgr.rs:238:36
[INFO] [stdout]     |
[INFO] [stdout] 238 |             if let Some(r) = table.get(k.clone(), lock) {
[INFO] [stdout]     |                                    ^^^ method not found in `Result<MutexGuard<'_, AssetTable<A>>, PoisonError<MutexGuard<'_, AssetTable<A>>>>`
[INFO] [stdout]     |
[INFO] [stdout] note: the method `get` exists on the type `std::sync::MutexGuard<'_, asset::AssetTable<A>>`
[INFO] [stdout]    --> src/asset.rs:205:5
[INFO] [stdout]     |
[INFO] [stdout] 205 |     pub fn get(&mut self, k: A::Key, lock: usize) -> Option<Option<Handle<A>>> {
[INFO] [stdout]     |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] help: consider using `Result::expect` to unwrap the `std::sync::MutexGuard<'_, asset::AssetTable<A>>` value, panicking if the value is a `Result::Err`
[INFO] [stdout]     |
[INFO] [stdout] 238 |             if let Some(r) = table.expect("REASON").get(k.clone(), lock) {
[INFO] [stdout]     |                                   +++++++++++++++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0599]: no method named `capacity_collect` found for enum `Result` in the current scope
[INFO] [stdout]    --> src/mgr.rs:301:31
[INFO] [stdout]     |
[INFO] [stdout] 301 |                         table.capacity_collect(&self.garbage, c, self.ref_garbage_lock)
[INFO] [stdout]     |                               ^^^^^^^^^^^^^^^^ method not found in `Result<MutexGuard<'_, AssetTable<A>>, PoisonError<MutexGuard<'_, AssetTable<A>>>>`
[INFO] [stdout]     |
[INFO] [stdout] note: the method `capacity_collect` exists on the type `std::sync::MutexGuard<'_, asset::AssetTable<A>>`
[INFO] [stdout]    --> src/asset.rs:316:5
[INFO] [stdout]     |
[INFO] [stdout] 316 | /     pub fn capacity_collect<G: Garbageer<A>>(
[INFO] [stdout] 317 | |         &mut self,
[INFO] [stdout] 318 | |         g: &G,
[INFO] [stdout] 319 | |         capacity: usize,
[INFO] [stdout] 320 | |         lock: usize,
[INFO] [stdout] 321 | |     ) -> (usize, usize) {
[INFO] [stdout]     | |_______________________^
[INFO] [stdout]     = help: items from traits can only be used if the trait is implemented and in scope
[INFO] [stdout] note: `allocator::Collect` defines an item `capacity_collect`, perhaps you need to implement it
[INFO] [stdout]    --> src/allocator.rs:12:1
[INFO] [stdout]     |
[INFO] [stdout] 12  | pub trait Collect: Send + Sync {
[INFO] [stdout]     | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] help: consider using `Result::expect` to unwrap the `std::sync::MutexGuard<'_, asset::AssetTable<A>>` value, panicking if the value is a `Result::Err`
[INFO] [stdout]     |
[INFO] [stdout] 301 |                         table.expect("REASON").capacity_collect(&self.garbage, c, self.ref_garbage_lock)
[INFO] [stdout]     |                              +++++++++++++++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0599]: no method named `check` found for enum `Result` in the current scope
[INFO] [stdout]    --> src/mgr.rs:253:25
[INFO] [stdout]     |
[INFO] [stdout] 253 |             match table.check(k.clone(), lock, true) {
[INFO] [stdout]     |                         ^^^^^ method not found in `Result<MutexGuard<'_, AssetTable<A>>, PoisonError<MutexGuard<'_, AssetTable<A>>>>`
[INFO] [stdout]     |
[INFO] [stdout] note: the method `check` exists on the type `std::sync::MutexGuard<'_, asset::AssetTable<A>>`
[INFO] [stdout]    --> src/asset.rs:227:5
[INFO] [stdout]     |
[INFO] [stdout] 227 | /     pub fn check(
[INFO] [stdout] 228 | |         &mut self,
[INFO] [stdout] 229 | |         k: A::Key,
[INFO] [stdout] 230 | |         lock: usize,
[INFO] [stdout] 231 | |         wait: bool,
[INFO] [stdout] 232 | |     ) -> Result1<Option<Handle<A>>, Option<Receiver<Result<Handle<A>>>>> {
[INFO] [stdout]     | |________________________________________________________________________^
[INFO] [stdout] help: consider using `Result::expect` to unwrap the `std::sync::MutexGuard<'_, asset::AssetTable<A>>` value, panicking if the value is a `Result::Err`
[INFO] [stdout]     |
[INFO] [stdout] 253 |             match table.expect("REASON").check(k.clone(), lock, true) {
[INFO] [stdout]     |                        +++++++++++++++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0599]: no method named `receive` found for enum `Result` in the current scope
[INFO] [stdout]    --> src/mgr.rs:307:28
[INFO] [stdout]     |
[INFO] [stdout] 307 |                     (table.receive(k, v, lock), len)
[INFO] [stdout]     |                            ^^^^^^^ method not found in `Result<MutexGuard<'_, AssetTable<A>>, PoisonError<MutexGuard<'_, AssetTable<A>>>>`
[INFO] [stdout]     |
[INFO] [stdout] note: the method `receive` exists on the type `std::sync::MutexGuard<'_, asset::AssetTable<A>>`
[INFO] [stdout]    --> src/asset.rs:263:5
[INFO] [stdout]     |
[INFO] [stdout] 263 | /     pub fn receive(
[INFO] [stdout] 264 | |         &mut self,
[INFO] [stdout] 265 | |         k: A::Key,
[INFO] [stdout] 266 | |         v: A,
[INFO] [stdout] 267 | |         lock: usize,
[INFO] [stdout] 268 | |     ) -> (Result<Handle<A>>, Option<AssetResult<A>>) {
[INFO] [stdout]     | |____________________________________________________^
[INFO] [stdout] help: consider using `Result::expect` to unwrap the `std::sync::MutexGuard<'_, asset::AssetTable<A>>` value, panicking if the value is a `Result::Err`
[INFO] [stdout]     |
[INFO] [stdout] 307 |                     (table.expect("REASON").receive(k, v, lock), len)
[INFO] [stdout]     |                           +++++++++++++++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0599]: no method named `remove` found for enum `Result` in the current scope
[INFO] [stdout]    --> src/mgr.rs:316:32
[INFO] [stdout]     |
[INFO] [stdout] 316 |                 (Err(e), table.remove(&k))
[INFO] [stdout]     |                                ^^^^^^ method not found in `Result<MutexGuard<'_, AssetTable<A>>, PoisonError<MutexGuard<'_, AssetTable<A>>>>`
[INFO] [stdout]     |
[INFO] [stdout] note: the method `remove` exists on the type `std::sync::MutexGuard<'_, asset::AssetTable<A>>`
[INFO] [stdout]    --> src/asset.rs:279:5
[INFO] [stdout]     |
[INFO] [stdout] 279 |     pub fn remove(&mut self, k: &A::Key) -> Option<AssetResult<A>> {
[INFO] [stdout]     |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] help: consider using `Result::expect` to unwrap the `std::sync::MutexGuard<'_, asset::AssetTable<A>>` value, panicking if the value is a `Result::Err`
[INFO] [stdout]     |
[INFO] [stdout] 316 |                 (Err(e), table.expect("REASON").remove(&k))
[INFO] [stdout]     |                               +++++++++++++++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0599]: no method named `cache_size` found for enum `Result` in the current scope
[INFO] [stdout]    --> src/mgr.rs:298:50
[INFO] [stdout]     |
[INFO] [stdout] 298 |                         let t = capacity + table.cache_size();
[INFO] [stdout]     |                                                  ^^^^^^^^^^ method not found in `Result<MutexGuard<'_, AssetTable<A>>, PoisonError<MutexGuard<'_, AssetTable<A>>>>`
[INFO] [stdout]     |
[INFO] [stdout] note: the method `cache_size` exists on the type `std::sync::MutexGuard<'_, asset::AssetTable<A>>`
[INFO] [stdout]    --> src/asset.rs:150:5
[INFO] [stdout]     |
[INFO] [stdout] 150 |     pub fn cache_size(&self) -> usize {
[INFO] [stdout]     |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] help: consider using `Result::expect` to unwrap the `std::sync::MutexGuard<'_, asset::AssetTable<A>>` value, panicking if the value is a `Result::Err`
[INFO] [stdout]     |
[INFO] [stdout] 298 |                         let t = capacity + table.expect("REASON").cache_size();
[INFO] [stdout]     |                                                 +++++++++++++++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0599]: no method named `cache_size` found for enum `Result` in the current scope
[INFO] [stdout]    --> src/mgr.rs:329:31
[INFO] [stdout]     |
[INFO] [stdout] 329 |             let mut c = table.cache_size();
[INFO] [stdout]     |                               ^^^^^^^^^^ method not found in `Result<MutexGuard<'_, AssetTable<A>>, PoisonError<MutexGuard<'_, AssetTable<A>>>>`
[INFO] [stdout]     |
[INFO] [stdout] note: the method `cache_size` exists on the type `std::sync::MutexGuard<'_, asset::AssetTable<A>>`
[INFO] [stdout]    --> src/asset.rs:150:5
[INFO] [stdout]     |
[INFO] [stdout] 150 |     pub fn cache_size(&self) -> usize {
[INFO] [stdout]     |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] help: consider using `Result::expect` to unwrap the `std::sync::MutexGuard<'_, asset::AssetTable<A>>` value, panicking if the value is a `Result::Err`
[INFO] [stdout]     |
[INFO] [stdout] 329 |             let mut c = table.expect("REASON").cache_size();
[INFO] [stdout]     |                              +++++++++++++++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0599]: no method named `capacity_collect` found for enum `Result` in the current scope
[INFO] [stdout]    --> src/mgr.rs:301:31
[INFO] [stdout]     |
[INFO] [stdout] 301 |                         table.capacity_collect(&self.garbage, c, self.ref_garbage_lock)
[INFO] [stdout]     |                               ^^^^^^^^^^^^^^^^ method not found in `Result<MutexGuard<'_, AssetTable<A>>, PoisonError<MutexGuard<'_, AssetTable<A>>>>`
[INFO] [stdout]     |
[INFO] [stdout] note: the method `capacity_collect` exists on the type `std::sync::MutexGuard<'_, asset::AssetTable<A>>`
[INFO] [stdout]    --> src/asset.rs:316:5
[INFO] [stdout]     |
[INFO] [stdout] 316 | /     pub fn capacity_collect<G: Garbageer<A>>(
[INFO] [stdout] 317 | |         &mut self,
[INFO] [stdout] 318 | |         g: &G,
[INFO] [stdout] 319 | |         capacity: usize,
[INFO] [stdout] 320 | |         lock: usize,
[INFO] [stdout] 321 | |     ) -> (usize, usize) {
[INFO] [stdout]     | |_______________________^
[INFO] [stdout]     = help: items from traits can only be used if the trait is implemented and in scope
[INFO] [stdout] note: `allocator::Collect` defines an item `capacity_collect`, perhaps you need to implement it
[INFO] [stdout]    --> src/allocator.rs:12:1
[INFO] [stdout]     |
[INFO] [stdout] 12  | pub trait Collect: Send + Sync {
[INFO] [stdout]     | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] help: consider using `Result::expect` to unwrap the `std::sync::MutexGuard<'_, asset::AssetTable<A>>` value, panicking if the value is a `Result::Err`
[INFO] [stdout]     |
[INFO] [stdout] 301 |                         table.expect("REASON").capacity_collect(&self.garbage, c, self.ref_garbage_lock)
[INFO] [stdout]     |                              +++++++++++++++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0599]: no method named `receive` found for enum `Result` in the current scope
[INFO] [stdout]    --> src/mgr.rs:307:28
[INFO] [stdout]     |
[INFO] [stdout] 307 |                     (table.receive(k, v, lock), len)
[INFO] [stdout]     |                            ^^^^^^^ method not found in `Result<MutexGuard<'_, AssetTable<A>>, PoisonError<MutexGuard<'_, AssetTable<A>>>>`
[INFO] [stdout]     |
[INFO] [stdout] note: the method `receive` exists on the type `std::sync::MutexGuard<'_, asset::AssetTable<A>>`
[INFO] [stdout]    --> src/asset.rs:263:5
[INFO] [stdout]     |
[INFO] [stdout] 263 | /     pub fn receive(
[INFO] [stdout] 264 | |         &mut self,
[INFO] [stdout] 265 | |         k: A::Key,
[INFO] [stdout] 266 | |         v: A,
[INFO] [stdout] 267 | |         lock: usize,
[INFO] [stdout] 268 | |     ) -> (Result<Handle<A>>, Option<AssetResult<A>>) {
[INFO] [stdout]     | |____________________________________________________^
[INFO] [stdout] help: consider using `Result::expect` to unwrap the `std::sync::MutexGuard<'_, asset::AssetTable<A>>` value, panicking if the value is a `Result::Err`
[INFO] [stdout]     |
[INFO] [stdout] 307 |                     (table.expect("REASON").receive(k, v, lock), len)
[INFO] [stdout]     |                           +++++++++++++++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0599]: no method named `timeout_collect` found for enum `Result` in the current scope
[INFO] [stdout]    --> src/mgr.rs:336:36
[INFO] [stdout]     |
[INFO] [stdout] 336 |             let (len, sub) = table.timeout_collect(&self.garbage, c, now, self.ref_garbage_lock);
[INFO] [stdout]     |                                    ^^^^^^^^^^^^^^^ method not found in `Result<MutexGuard<'_, AssetTable<A>>, PoisonError<MutexGuard<'_, AssetTable<A>>>>`
[INFO] [stdout]     |
[INFO] [stdout] note: the method `timeout_collect` exists on the type `std::sync::MutexGuard<'_, asset::AssetTable<A>>`
[INFO] [stdout]    --> src/asset.rs:283:5
[INFO] [stdout]     |
[INFO] [stdout] 283 | /     pub fn timeout_collect<G: Garbageer<A>>(
[INFO] [stdout] 284 | |         &mut self,
[INFO] [stdout] 285 | |         g: &G,
[INFO] [stdout] 286 | |         capacity: usize,
[INFO] [stdout] 287 | |         now: u64,
[INFO] [stdout] 288 | |         lock: usize,
[INFO] [stdout] 289 | |     ) -> (usize, usize) {
[INFO] [stdout]     | |_______________________^
[INFO] [stdout]     = help: items from traits can only be used if the trait is implemented and in scope
[INFO] [stdout] note: `allocator::Collect` defines an item `timeout_collect`, perhaps you need to implement it
[INFO] [stdout]    --> src/allocator.rs:12:1
[INFO] [stdout]     |
[INFO] [stdout] 12  | pub trait Collect: Send + Sync {
[INFO] [stdout]     | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] help: consider using `Result::expect` to unwrap the `std::sync::MutexGuard<'_, asset::AssetTable<A>>` value, panicking if the value is a `Result::Err`
[INFO] [stdout]     |
[INFO] [stdout] 336 |             let (len, sub) = table.expect("REASON").timeout_collect(&self.garbage, c, now, self.ref_garbage_lock);
[INFO] [stdout]     |                                   +++++++++++++++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0599]: no method named `cache_size` found for enum `Result` in the current scope
[INFO] [stdout]    --> src/mgr.rs:353:31
[INFO] [stdout]     |
[INFO] [stdout] 353 |             let mut c = table.cache_size();
[INFO] [stdout]     |                               ^^^^^^^^^^ method not found in `Result<MutexGuard<'_, AssetTable<A>>, PoisonError<MutexGuard<'_, AssetTable<A>>>>`
[INFO] [stdout]     |
[INFO] [stdout] note: the method `cache_size` exists on the type `std::sync::MutexGuard<'_, asset::AssetTable<A>>`
[INFO] [stdout]    --> src/asset.rs:150:5
[INFO] [stdout]     |
[INFO] [stdout] 150 |     pub fn cache_size(&self) -> usize {
[INFO] [stdout]     |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] help: consider using `Result::expect` to unwrap the `std::sync::MutexGuard<'_, asset::AssetTable<A>>` value, panicking if the value is a `Result::Err`
[INFO] [stdout]     |
[INFO] [stdout] 353 |             let mut c = table.expect("REASON").cache_size();
[INFO] [stdout]     |                              +++++++++++++++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0599]: no method named `remove` found for enum `Result` in the current scope
[INFO] [stdout]    --> src/mgr.rs:316:32
[INFO] [stdout]     |
[INFO] [stdout] 316 |                 (Err(e), table.remove(&k))
[INFO] [stdout]     |                                ^^^^^^ method not found in `Result<MutexGuard<'_, AssetTable<A>>, PoisonError<MutexGuard<'_, AssetTable<A>>>>`
[INFO] [stdout]     |
[INFO] [stdout] note: the method `remove` exists on the type `std::sync::MutexGuard<'_, asset::AssetTable<A>>`
[INFO] [stdout]    --> src/asset.rs:279:5
[INFO] [stdout]     |
[INFO] [stdout] 279 |     pub fn remove(&mut self, k: &A::Key) -> Option<AssetResult<A>> {
[INFO] [stdout]     |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] help: consider using `Result::expect` to unwrap the `std::sync::MutexGuard<'_, asset::AssetTable<A>>` value, panicking if the value is a `Result::Err`
[INFO] [stdout]     |
[INFO] [stdout] 316 |                 (Err(e), table.expect("REASON").remove(&k))
[INFO] [stdout]     |                               +++++++++++++++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0599]: no method named `capacity_collect` found for enum `Result` in the current scope
[INFO] [stdout]    --> src/mgr.rs:360:36
[INFO] [stdout]     |
[INFO] [stdout] 360 |             let (len, sub) = table.capacity_collect(&self.garbage, c, self.ref_garbage_lock);
[INFO] [stdout]     |                                    ^^^^^^^^^^^^^^^^ method not found in `Result<MutexGuard<'_, AssetTable<A>>, PoisonError<MutexGuard<'_, AssetTable<A>>>>`
[INFO] [stdout]     |
[INFO] [stdout] note: the method `capacity_collect` exists on the type `std::sync::MutexGuard<'_, asset::AssetTable<A>>`
[INFO] [stdout]    --> src/asset.rs:316:5
[INFO] [stdout]     |
[INFO] [stdout] 316 | /     pub fn capacity_collect<G: Garbageer<A>>(
[INFO] [stdout] 317 | |         &mut self,
[INFO] [stdout] 318 | |         g: &G,
[INFO] [stdout] 319 | |         capacity: usize,
[INFO] [stdout] 320 | |         lock: usize,
[INFO] [stdout] 321 | |     ) -> (usize, usize) {
[INFO] [stdout]     | |_______________________^
[INFO] [stdout]     = help: items from traits can only be used if the trait is implemented and in scope
[INFO] [stdout] note: `allocator::Collect` defines an item `capacity_collect`, perhaps you need to implement it
[INFO] [stdout]    --> src/allocator.rs:12:1
[INFO] [stdout]     |
[INFO] [stdout] 12  | pub trait Collect: Send + Sync {
[INFO] [stdout]     | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] help: consider using `Result::expect` to unwrap the `std::sync::MutexGuard<'_, asset::AssetTable<A>>` value, panicking if the value is a `Result::Err`
[INFO] [stdout]     |
[INFO] [stdout] 360 |             let (len, sub) = table.expect("REASON").capacity_collect(&self.garbage, c, self.ref_garbage_lock);
[INFO] [stdout]     |                                   +++++++++++++++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0599]: no method named `cache_size` found for enum `Result` in the current scope
[INFO] [stdout]    --> src/mgr.rs:329:31
[INFO] [stdout]     |
[INFO] [stdout] 329 |             let mut c = table.cache_size();
[INFO] [stdout]     |                               ^^^^^^^^^^ method not found in `Result<MutexGuard<'_, AssetTable<A>>, PoisonError<MutexGuard<'_, AssetTable<A>>>>`
[INFO] [stdout]     |
[INFO] [stdout] note: the method `cache_size` exists on the type `std::sync::MutexGuard<'_, asset::AssetTable<A>>`
[INFO] [stdout]    --> src/asset.rs:150:5
[INFO] [stdout]     |
[INFO] [stdout] 150 |     pub fn cache_size(&self) -> usize {
[INFO] [stdout]     |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] help: consider using `Result::expect` to unwrap the `std::sync::MutexGuard<'_, asset::AssetTable<A>>` value, panicking if the value is a `Result::Err`
[INFO] [stdout]     |
[INFO] [stdout] 329 |             let mut c = table.expect("REASON").cache_size();
[INFO] [stdout]     |                              +++++++++++++++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0599]: no method named `map_keys` found for enum `Result` in the current scope
[INFO] [stdout]    --> src/mgr.rs:372:24
[INFO] [stdout]     |
[INFO] [stdout] 372 |         for k in table.map_keys() {
[INFO] [stdout]     |                        ^^^^^^^^ method not found in `Result<MutexGuard<'_, AssetTable<A>>, PoisonError<MutexGuard<'_, AssetTable<A>>>>`
[INFO] [stdout]     |
[INFO] [stdout] note: the method `map_keys` exists on the type `std::sync::MutexGuard<'_, asset::AssetTable<A>>`
[INFO] [stdout]    --> src/asset.rs:166:5
[INFO] [stdout]     |
[INFO] [stdout] 166 |     pub fn map_keys(&self) -> Keys<'_, <A as Asset>::Key, AssetResult<A>> {
[INFO] [stdout]     |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] help: consider using `Result::expect` to unwrap the `std::sync::MutexGuard<'_, asset::AssetTable<A>>` value, panicking if the value is a `Result::Err`
[INFO] [stdout]     |
[INFO] [stdout] 372 |         for k in table.expect("REASON").map_keys() {
[INFO] [stdout]     |                       +++++++++++++++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0599]: no method named `timeout_collect` found for enum `Result` in the current scope
[INFO] [stdout]    --> src/mgr.rs:336:36
[INFO] [stdout]     |
[INFO] [stdout] 336 |             let (len, sub) = table.timeout_collect(&self.garbage, c, now, self.ref_garbage_lock);
[INFO] [stdout]     |                                    ^^^^^^^^^^^^^^^ method not found in `Result<MutexGuard<'_, AssetTable<A>>, PoisonError<MutexGuard<'_, AssetTable<A>>>>`
[INFO] [stdout]     |
[INFO] [stdout] note: the method `timeout_collect` exists on the type `std::sync::MutexGuard<'_, asset::AssetTable<A>>`
[INFO] [stdout]    --> src/asset.rs:283:5
[INFO] [stdout]     |
[INFO] [stdout] 283 | /     pub fn timeout_collect<G: Garbageer<A>>(
[INFO] [stdout] 284 | |         &mut self,
[INFO] [stdout] 285 | |         g: &G,
[INFO] [stdout] 286 | |         capacity: usize,
[INFO] [stdout] 287 | |         now: u64,
[INFO] [stdout] 288 | |         lock: usize,
[INFO] [stdout] 289 | |     ) -> (usize, usize) {
[INFO] [stdout]     | |_______________________^
[INFO] [stdout]     = help: items from traits can only be used if the trait is implemented and in scope
[INFO] [stdout] note: `allocator::Collect` defines an item `timeout_collect`, perhaps you need to implement it
[INFO] [stdout]    --> src/allocator.rs:12:1
[INFO] [stdout]     |
[INFO] [stdout] 12  | pub trait Collect: Send + Sync {
[INFO] [stdout]     | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] help: consider using `Result::expect` to unwrap the `std::sync::MutexGuard<'_, asset::AssetTable<A>>` value, panicking if the value is a `Result::Err`
[INFO] [stdout]     |
[INFO] [stdout] 336 |             let (len, sub) = table.expect("REASON").timeout_collect(&self.garbage, c, now, self.ref_garbage_lock);
[INFO] [stdout]     |                                   +++++++++++++++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0599]: no method named `cache_iter` found for enum `Result` in the current scope
[INFO] [stdout]    --> src/mgr.rs:379:32
[INFO] [stdout]     |
[INFO] [stdout] 379 |         for (k, item) in table.cache_iter() {
[INFO] [stdout]     |                                ^^^^^^^^^^ method not found in `Result<MutexGuard<'_, AssetTable<A>>, PoisonError<MutexGuard<'_, AssetTable<A>>>>`
[INFO] [stdout]     |
[INFO] [stdout] note: the method `cache_iter` exists on the type `std::sync::MutexGuard<'_, asset::AssetTable<A>>`
[INFO] [stdout]    --> src/asset.rs:170:5
[INFO] [stdout]     |
[INFO] [stdout] 170 |     pub fn cache_iter(&self) -> Iter<'_, <A as Asset>::Key, Item<A>> {
[INFO] [stdout]     |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] help: consider using `Result::expect` to unwrap the `std::sync::MutexGuard<'_, asset::AssetTable<A>>` value, panicking if the value is a `Result::Err`
[INFO] [stdout]     |
[INFO] [stdout] 379 |         for (k, item) in table.expect("REASON").cache_iter() {
[INFO] [stdout]     |                               +++++++++++++++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0599]: no method named `cache_size` found for enum `Result` in the current scope
[INFO] [stdout]    --> src/mgr.rs:353:31
[INFO] [stdout]     |
[INFO] [stdout] 353 |             let mut c = table.cache_size();
[INFO] [stdout]     |                               ^^^^^^^^^^ method not found in `Result<MutexGuard<'_, AssetTable<A>>, PoisonError<MutexGuard<'_, AssetTable<A>>>>`
[INFO] [stdout]     |
[INFO] [stdout] note: the method `cache_size` exists on the type `std::sync::MutexGuard<'_, asset::AssetTable<A>>`
[INFO] [stdout]    --> src/asset.rs:150:5
[INFO] [stdout]     |
[INFO] [stdout] 150 |     pub fn cache_size(&self) -> usize {
[INFO] [stdout]     |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] help: consider using `Result::expect` to unwrap the `std::sync::MutexGuard<'_, asset::AssetTable<A>>` value, panicking if the value is a `Result::Err`
[INFO] [stdout]     |
[INFO] [stdout] 353 |             let mut c = table.expect("REASON").cache_size();
[INFO] [stdout]     |                              +++++++++++++++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0599]: no method named `account` found for enum `Result` in the current scope
[INFO] [stdout]    --> src/mgr.rs:388:9
[INFO] [stdout]     |
[INFO] [stdout] 388 |         table.account(&mut account);
[INFO] [stdout]     |               ^^^^^^^ method not found in `Result<MutexGuard<'_, AssetTable<A>>, PoisonError<MutexGuard<'_, AssetTable<A>>>>`
[INFO] [stdout]     |
[INFO] [stdout] note: the method `account` exists on the type `std::sync::MutexGuard<'_, asset::AssetTable<A>>`
[INFO] [stdout]    --> src/asset.rs:349:2
[INFO] [stdout]     |
[INFO] [stdout] 349 |     pub fn account(&self, account: &mut AssetMgrAccount) {
[INFO] [stdout]     |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     = help: items from traits can only be used if the trait is implemented and in scope
[INFO] [stdout] note: `allocator::Collect` defines an item `account`, perhaps you need to implement it
[INFO] [stdout]    --> src/allocator.rs:12:1
[INFO] [stdout]     |
[INFO] [stdout] 12  | pub trait Collect: Send + Sync {
[INFO] [stdout]     | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] help: consider using `Result::expect` to unwrap the `std::sync::MutexGuard<'_, asset::AssetTable<A>>` value, panicking if the value is a `Result::Err`
[INFO] [stdout]     |
[INFO] [stdout] 388 |         table.expect("REASON").account(&mut account);
[INFO] [stdout]     |              +++++++++++++++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0609]: no field `1` on type `Result<std::sync::MutexGuard<'_, (VecDeque<homogeneous::Item<V>>, usize)>, PoisonError<std::sync::MutexGuard<'_, (VecDeque<homogeneous::Item<V>>, usize)>>>`
[INFO] [stdout]   --> src/homogeneous.rs:50:11
[INFO] [stdout]    |
[INFO] [stdout] 50 |         p.1 += v.size();
[INFO] [stdout]    |           ^ unknown field
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0609]: no field `0` on type `Result<std::sync::MutexGuard<'_, (VecDeque<homogeneous::Item<V>>, usize)>, PoisonError<std::sync::MutexGuard<'_, (VecDeque<homogeneous::Item<V>>, usize)>>>`
[INFO] [stdout]   --> src/homogeneous.rs:51:11
[INFO] [stdout]    |
[INFO] [stdout] 51 |         p.0.push_back(Item(v, timeout));
[INFO] [stdout]    |           ^ unknown field
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0609]: no field `1` on type `Result<std::sync::MutexGuard<'_, (VecDeque<homogeneous::Item<V>>, usize)>, PoisonError<std::sync::MutexGuard<'_, (VecDeque<homogeneous::Item<V>>, usize)>>>`
[INFO] [stdout]    --> src/homogeneous.rs:105:47
[INFO] [stdout]     |
[INFO] [stdout] 105 |             cache_size: self.lock.pool.lock().1,
[INFO] [stdout]     |                                               ^ unknown field
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0609]: no field `0` on type `Result<std::sync::MutexGuard<'_, (VecDeque<homogeneous::Item<V>>, usize)>, PoisonError<std::sync::MutexGuard<'_, (VecDeque<homogeneous::Item<V>>, usize)>>>`
[INFO] [stdout]    --> src/homogeneous.rs:119:31
[INFO] [stdout]     |
[INFO] [stdout] 119 |         if let Some(item) = p.0.pop_back() {
[INFO] [stdout]     |                               ^ unknown field
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0609]: no field `1` on type `Result<std::sync::MutexGuard<'_, (VecDeque<homogeneous::Item<V>>, usize)>, PoisonError<std::sync::MutexGuard<'_, (VecDeque<homogeneous::Item<V>>, usize)>>>`
[INFO] [stdout]    --> src/homogeneous.rs:120:15
[INFO] [stdout]     |
[INFO] [stdout] 120 |             p.1 -= item.0.size();
[INFO] [stdout]     |               ^ unknown field
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0609]: no field `0` on type `Result<std::sync::MutexGuard<'_, (VecDeque<homogeneous::Item<V>>, usize)>, PoisonError<std::sync::MutexGuard<'_, (VecDeque<homogeneous::Item<V>>, usize)>>>`
[INFO] [stdout]    --> src/homogeneous.rs:136:26
[INFO] [stdout]     |
[INFO] [stdout] 136 |         for item in pool.0.iter() {
[INFO] [stdout]     |                          ^ unknown field
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0609]: no field `0` on type `Result<std::sync::MutexGuard<'_, (VecDeque<homogeneous::Item<V>>, usize)>, PoisonError<std::sync::MutexGuard<'_, (VecDeque<homogeneous::Item<V>>, usize)>>>`
[INFO] [stdout]    --> src/homogeneous.rs:142:22
[INFO] [stdout]     |
[INFO] [stdout] 142 |         if i >= pool.0.len() {
[INFO] [stdout]     |                      ^ unknown field
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0609]: no field `0` on type `Result<std::sync::MutexGuard<'_, (VecDeque<homogeneous::Item<V>>, usize)>, PoisonError<std::sync::MutexGuard<'_, (VecDeque<homogeneous::Item<V>>, usize)>>>`
[INFO] [stdout]    --> src/homogeneous.rs:145:34
[INFO] [stdout]     |
[INFO] [stdout] 145 |         if let Some(item) = pool.0.swap_remove_front(i) {
[INFO] [stdout]     |                                  ^ unknown field
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0609]: no field `1` on type `Result<std::sync::MutexGuard<'_, (VecDeque<homogeneous::Item<V>>, usize)>, PoisonError<std::sync::MutexGuard<'_, (VecDeque<homogeneous::Item<V>>, usize)>>>`
[INFO] [stdout]    --> src/homogeneous.rs:146:18
[INFO] [stdout]     |
[INFO] [stdout] 146 |             pool.1 -= item.0.size();
[INFO] [stdout]     |                  ^ unknown field
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0599]: no method named `capacity_collect` found for enum `Result` in the current scope
[INFO] [stdout]    --> src/mgr.rs:360:36
[INFO] [stdout]     |
[INFO] [stdout] 360 |             let (len, sub) = table.capacity_collect(&self.garbage, c, self.ref_garbage_lock);
[INFO] [stdout]     |                                    ^^^^^^^^^^^^^^^^ method not found in `Result<MutexGuard<'_, AssetTable<A>>, PoisonError<MutexGuard<'_, AssetTable<A>>>>`
[INFO] [stdout]     |
[INFO] [stdout] note: the method `capacity_collect` exists on the type `std::sync::MutexGuard<'_, asset::AssetTable<A>>`
[INFO] [stdout]    --> src/asset.rs:316:5
[INFO] [stdout]     |
[INFO] [stdout] 316 | /     pub fn capacity_collect<G: Garbageer<A>>(
[INFO] [stdout] 317 | |         &mut self,
[INFO] [stdout] 318 | |         g: &G,
[INFO] [stdout] 319 | |         capacity: usize,
[INFO] [stdout] 320 | |         lock: usize,
[INFO] [stdout] 321 | |     ) -> (usize, usize) {
[INFO] [stdout]     | |_______________________^
[INFO] [stdout]     = help: items from traits can only be used if the trait is implemented and in scope
[INFO] [stdout] note: `allocator::Collect` defines an item `capacity_collect`, perhaps you need to implement it
[INFO] [stdout]    --> src/allocator.rs:12:1
[INFO] [stdout]     |
[INFO] [stdout] 12  | pub trait Collect: Send + Sync {
[INFO] [stdout]     | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] help: consider using `Result::expect` to unwrap the `std::sync::MutexGuard<'_, asset::AssetTable<A>>` value, panicking if the value is a `Result::Err`
[INFO] [stdout]     |
[INFO] [stdout] 360 |             let (len, sub) = table.expect("REASON").capacity_collect(&self.garbage, c, self.ref_garbage_lock);
[INFO] [stdout]     |                                   +++++++++++++++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0609]: no field `1` on type `Result<std::sync::MutexGuard<'_, (VecDeque<homogeneous::Item<V>>, usize)>, PoisonError<std::sync::MutexGuard<'_, (VecDeque<homogeneous::Item<V>>, usize)>>>`
[INFO] [stdout]    --> src/homogeneous.rs:160:11
[INFO] [stdout]     |
[INFO] [stdout] 160 |         p.1 += v.size();
[INFO] [stdout]     |           ^ unknown field
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0609]: no field `0` on type `Result<std::sync::MutexGuard<'_, (VecDeque<homogeneous::Item<V>>, usize)>, PoisonError<std::sync::MutexGuard<'_, (VecDeque<homogeneous::Item<V>>, usize)>>>`
[INFO] [stdout]    --> src/homogeneous.rs:161:11
[INFO] [stdout]     |
[INFO] [stdout] 161 |         p.0.push_back(Item(v, timeout));
[INFO] [stdout]     |           ^ unknown field
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0609]: no field `0` on type `Result<std::sync::MutexGuard<'_, (VecDeque<homogeneous::Item<V>>, usize)>, PoisonError<std::sync::MutexGuard<'_, (VecDeque<homogeneous::Item<V>>, usize)>>>`
[INFO] [stdout]    --> src/homogeneous.rs:166:31
[INFO] [stdout]     |
[INFO] [stdout] 166 |         if let Some(item) = p.0.pop_back() {
[INFO] [stdout]     |                               ^ unknown field
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0609]: no field `1` on type `Result<std::sync::MutexGuard<'_, (VecDeque<homogeneous::Item<V>>, usize)>, PoisonError<std::sync::MutexGuard<'_, (VecDeque<homogeneous::Item<V>>, usize)>>>`
[INFO] [stdout]    --> src/homogeneous.rs:167:15
[INFO] [stdout]     |
[INFO] [stdout] 167 |             p.1 -= item.0.size();
[INFO] [stdout]     |               ^ unknown field
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0609]: no field `0` on type `Result<std::sync::MutexGuard<'_, (VecDeque<homogeneous::Item<V>>, usize)>, PoisonError<std::sync::MutexGuard<'_, (VecDeque<homogeneous::Item<V>>, usize)>>>`
[INFO] [stdout]    --> src/homogeneous.rs:181:26
[INFO] [stdout]     |
[INFO] [stdout] 181 |         for item in pool.0.iter() {
[INFO] [stdout]     |                          ^ unknown field
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0609]: no field `0` on type `Result<std::sync::MutexGuard<'_, (VecDeque<homogeneous::Item<V>>, usize)>, PoisonError<std::sync::MutexGuard<'_, (VecDeque<homogeneous::Item<V>>, usize)>>>`
[INFO] [stdout]    --> src/homogeneous.rs:187:22
[INFO] [stdout]     |
[INFO] [stdout] 187 |         if i >= pool.0.len() {
[INFO] [stdout]     |                      ^ unknown field
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0609]: no field `0` on type `Result<std::sync::MutexGuard<'_, (VecDeque<homogeneous::Item<V>>, usize)>, PoisonError<std::sync::MutexGuard<'_, (VecDeque<homogeneous::Item<V>>, usize)>>>`
[INFO] [stdout]    --> src/homogeneous.rs:190:34
[INFO] [stdout]     |
[INFO] [stdout] 190 |         if let Some(item) = pool.0.swap_remove_front(i) {
[INFO] [stdout]     |                                  ^ unknown field
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0609]: no field `1` on type `Result<std::sync::MutexGuard<'_, (VecDeque<homogeneous::Item<V>>, usize)>, PoisonError<std::sync::MutexGuard<'_, (VecDeque<homogeneous::Item<V>>, usize)>>>`
[INFO] [stdout]    --> src/homogeneous.rs:191:18
[INFO] [stdout]     |
[INFO] [stdout] 191 |             pool.1 -= item.0.size();
[INFO] [stdout]     |                  ^ unknown field
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0609]: no field `0` on type `Result<std::sync::MutexGuard<'_, (VecDeque<homogeneous::Item<V>>, usize)>, PoisonError<std::sync::MutexGuard<'_, (VecDeque<homogeneous::Item<V>>, usize)>>>`
[INFO] [stdout]    --> src/homogeneous.rs:206:21
[INFO] [stdout]     |
[INFO] [stdout] 206 |         while !pool.0.is_empty() {
[INFO] [stdout]     |                     ^ unknown field
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0609]: no field `0` on type `Result<std::sync::MutexGuard<'_, (VecDeque<homogeneous::Item<V>>, usize)>, PoisonError<std::sync::MutexGuard<'_, (VecDeque<homogeneous::Item<V>>, usize)>>>`
[INFO] [stdout]    --> src/homogeneous.rs:207:26
[INFO] [stdout]     |
[INFO] [stdout] 207 |             let r = pool.0.front().unwrap();
[INFO] [stdout]     |                          ^ unknown field
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0609]: no field `0` on type `Result<std::sync::MutexGuard<'_, (VecDeque<homogeneous::Item<V>>, usize)>, PoisonError<std::sync::MutexGuard<'_, (VecDeque<homogeneous::Item<V>>, usize)>>>`
[INFO] [stdout]    --> src/homogeneous.rs:212:26
[INFO] [stdout]     |
[INFO] [stdout] 212 |             let r = pool.0.pop_front().unwrap();
[INFO] [stdout]     |                          ^ unknown field
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0609]: no field `1` on type `Result<std::sync::MutexGuard<'_, (VecDeque<homogeneous::Item<V>>, usize)>, PoisonError<std::sync::MutexGuard<'_, (VecDeque<homogeneous::Item<V>>, usize)>>>`
[INFO] [stdout]    --> src/homogeneous.rs:217:18
[INFO] [stdout]     |
[INFO] [stdout] 217 |             pool.1 -= sub;
[INFO] [stdout]     |                  ^ unknown field
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0609]: no field `0` on type `Result<std::sync::MutexGuard<'_, (VecDeque<homogeneous::Item<V>>, usize)>, PoisonError<std::sync::MutexGuard<'_, (VecDeque<homogeneous::Item<V>>, usize)>>>`
[INFO] [stdout]    --> src/homogeneous.rs:229:46
[INFO] [stdout]     |
[INFO] [stdout] 229 |         while size > capacity + sub && !pool.0.is_empty() {
[INFO] [stdout]     |                                              ^ unknown field
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0609]: no field `0` on type `Result<std::sync::MutexGuard<'_, (VecDeque<homogeneous::Item<V>>, usize)>, PoisonError<std::sync::MutexGuard<'_, (VecDeque<homogeneous::Item<V>>, usize)>>>`
[INFO] [stdout]    --> src/homogeneous.rs:230:26
[INFO] [stdout]     |
[INFO] [stdout] 230 |             let r = pool.0.pop_front().unwrap();
[INFO] [stdout]     |                          ^ unknown field
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0609]: no field `1` on type `Result<std::sync::MutexGuard<'_, (VecDeque<homogeneous::Item<V>>, usize)>, PoisonError<std::sync::MutexGuard<'_, (VecDeque<homogeneous::Item<V>>, usize)>>>`
[INFO] [stdout]    --> src/homogeneous.rs:235:18
[INFO] [stdout]     |
[INFO] [stdout] 235 |             pool.1 -= sub;
[INFO] [stdout]     |                  ^ unknown field
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0609]: no field `0` on type `Result<std::sync::MutexGuard<'_, (VecDeque<homogeneous::Item<V>>, usize)>, PoisonError<std::sync::MutexGuard<'_, (VecDeque<homogeneous::Item<V>>, usize)>>>`
[INFO] [stdout]    --> src/homogeneous.rs:245:20
[INFO] [stdout]     |
[INFO] [stdout] 245 |         for item in pool.0.iter() {
[INFO] [stdout]     |                          ^ unknown field
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0599]: no method named `map_keys` found for enum `Result` in the current scope
[INFO] [stdout]    --> src/mgr.rs:372:24
[INFO] [stdout]     |
[INFO] [stdout] 372 |         for k in table.map_keys() {
[INFO] [stdout]     |                        ^^^^^^^^ method not found in `Result<MutexGuard<'_, AssetTable<A>>, PoisonError<MutexGuard<'_, AssetTable<A>>>>`
[INFO] [stdout]     |
[INFO] [stdout] note: the method `map_keys` exists on the type `std::sync::MutexGuard<'_, asset::AssetTable<A>>`
[INFO] [stdout]    --> src/asset.rs:166:5
[INFO] [stdout]     |
[INFO] [stdout] 166 |     pub fn map_keys(&self) -> Keys<'_, <A as Asset>::Key, AssetResult<A>> {
[INFO] [stdout]     |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] help: consider using `Result::expect` to unwrap the `std::sync::MutexGuard<'_, asset::AssetTable<A>>` value, panicking if the value is a `Result::Err`
[INFO] [stdout]     |
[INFO] [stdout] 372 |         for k in table.expect("REASON").map_keys() {
[INFO] [stdout]     |                       +++++++++++++++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0599]: no method named `cache_iter` found for enum `Result` in the current scope
[INFO] [stdout]    --> src/mgr.rs:379:32
[INFO] [stdout]     |
[INFO] [stdout] 379 |         for (k, item) in table.cache_iter() {
[INFO] [stdout]     |                                ^^^^^^^^^^ method not found in `Result<MutexGuard<'_, AssetTable<A>>, PoisonError<MutexGuard<'_, AssetTable<A>>>>`
[INFO] [stdout]     |
[INFO] [stdout] note: the method `cache_iter` exists on the type `std::sync::MutexGuard<'_, asset::AssetTable<A>>`
[INFO] [stdout]    --> src/asset.rs:170:5
[INFO] [stdout]     |
[INFO] [stdout] 170 |     pub fn cache_iter(&self) -> Iter<'_, <A as Asset>::Key, Item<A>> {
[INFO] [stdout]     |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] help: consider using `Result::expect` to unwrap the `std::sync::MutexGuard<'_, asset::AssetTable<A>>` value, panicking if the value is a `Result::Err`
[INFO] [stdout]     |
[INFO] [stdout] 379 |         for (k, item) in table.expect("REASON").cache_iter() {
[INFO] [stdout]     |                               +++++++++++++++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0599]: no method named `account` found for enum `Result` in the current scope
[INFO] [stdout]    --> src/mgr.rs:388:9
[INFO] [stdout]     |
[INFO] [stdout] 388 |         table.account(&mut account);
[INFO] [stdout]     |               ^^^^^^^ method not found in `Result<MutexGuard<'_, AssetTable<A>>, PoisonError<MutexGuard<'_, AssetTable<A>>>>`
[INFO] [stdout]     |
[INFO] [stdout] note: the method `account` exists on the type `std::sync::MutexGuard<'_, asset::AssetTable<A>>`
[INFO] [stdout]    --> src/asset.rs:349:2
[INFO] [stdout]     |
[INFO] [stdout] 349 |     pub fn account(&self, account: &mut AssetMgrAccount) {
[INFO] [stdout]     |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     = help: items from traits can only be used if the trait is implemented and in scope
[INFO] [stdout] note: `allocator::Collect` defines an item `account`, perhaps you need to implement it
[INFO] [stdout]    --> src/allocator.rs:12:1
[INFO] [stdout]     |
[INFO] [stdout] 12  | pub trait Collect: Send + Sync {
[INFO] [stdout]     | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] help: consider using `Result::expect` to unwrap the `std::sync::MutexGuard<'_, asset::AssetTable<A>>` value, panicking if the value is a `Result::Err`
[INFO] [stdout]     |
[INFO] [stdout] 388 |         table.expect("REASON").account(&mut account);
[INFO] [stdout]     |              +++++++++++++++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0609]: no field `1` on type `Result<std::sync::MutexGuard<'_, (VecDeque<homogeneous::Item<V>>, usize)>, PoisonError<std::sync::MutexGuard<'_, (VecDeque<homogeneous::Item<V>>, usize)>>>`
[INFO] [stdout]   --> src/homogeneous.rs:50:11
[INFO] [stdout]    |
[INFO] [stdout] 50 |         p.1 += v.size();
[INFO] [stdout]    |           ^ unknown field
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0609]: no field `0` on type `Result<std::sync::MutexGuard<'_, (VecDeque<homogeneous::Item<V>>, usize)>, PoisonError<std::sync::MutexGuard<'_, (VecDeque<homogeneous::Item<V>>, usize)>>>`
[INFO] [stdout]   --> src/homogeneous.rs:51:11
[INFO] [stdout]    |
[INFO] [stdout] 51 |         p.0.push_back(Item(v, timeout));
[INFO] [stdout]    |           ^ unknown field
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0609]: no field `1` on type `Result<std::sync::MutexGuard<'_, (VecDeque<homogeneous::Item<V>>, usize)>, PoisonError<std::sync::MutexGuard<'_, (VecDeque<homogeneous::Item<V>>, usize)>>>`
[INFO] [stdout]    --> src/homogeneous.rs:105:47
[INFO] [stdout]     |
[INFO] [stdout] 105 |             cache_size: self.lock.pool.lock().1,
[INFO] [stdout]     |                                               ^ unknown field
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0609]: no field `0` on type `Result<std::sync::MutexGuard<'_, (VecDeque<homogeneous::Item<V>>, usize)>, PoisonError<std::sync::MutexGuard<'_, (VecDeque<homogeneous::Item<V>>, usize)>>>`
[INFO] [stdout]    --> src/homogeneous.rs:119:31
[INFO] [stdout]     |
[INFO] [stdout] 119 |         if let Some(item) = p.0.pop_back() {
[INFO] [stdout]     |                               ^ unknown field
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0609]: no field `1` on type `Result<std::sync::MutexGuard<'_, (VecDeque<homogeneous::Item<V>>, usize)>, PoisonError<std::sync::MutexGuard<'_, (VecDeque<homogeneous::Item<V>>, usize)>>>`
[INFO] [stdout]    --> src/homogeneous.rs:120:15
[INFO] [stdout]     |
[INFO] [stdout] 120 |             p.1 -= item.0.size();
[INFO] [stdout]     |               ^ unknown field
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: aborting due to 53 previous errors
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] Some errors have detailed explanations: E0599, E0609, E0615.
[INFO] [stdout] 
[INFO] [stdout] For more information about an error, try `rustc --explain E0599`.
[INFO] [stdout] 
[INFO] [stdout] error[E0609]: no field `0` on type `Result<std::sync::MutexGuard<'_, (VecDeque<homogeneous::Item<V>>, usize)>, PoisonError<std::sync::MutexGuard<'_, (VecDeque<homogeneous::Item<V>>, usize)>>>`
[INFO] [stdout]    --> src/homogeneous.rs:136:26
[INFO] [stdout]     |
[INFO] [stdout] 136 |         for item in pool.0.iter() {
[INFO] [stdout]     |                          ^ unknown field
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0609]: no field `0` on type `Result<std::sync::MutexGuard<'_, (VecDeque<homogeneous::Item<V>>, usize)>, PoisonError<std::sync::MutexGuard<'_, (VecDeque<homogeneous::Item<V>>, usize)>>>`
[INFO] [stdout]    --> src/homogeneous.rs:142:22
[INFO] [stdout]     |
[INFO] [stdout] 142 |         if i >= pool.0.len() {
[INFO] [stdout]     |                      ^ unknown field
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0609]: no field `0` on type `Result<std::sync::MutexGuard<'_, (VecDeque<homogeneous::Item<V>>, usize)>, PoisonError<std::sync::MutexGuard<'_, (VecDeque<homogeneous::Item<V>>, usize)>>>`
[INFO] [stdout]    --> src/homogeneous.rs:145:34
[INFO] [stdout]     |
[INFO] [stdout] 145 |         if let Some(item) = pool.0.swap_remove_front(i) {
[INFO] [stdout]     |                                  ^ unknown field
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0609]: no field `1` on type `Result<std::sync::MutexGuard<'_, (VecDeque<homogeneous::Item<V>>, usize)>, PoisonError<std::sync::MutexGuard<'_, (VecDeque<homogeneous::Item<V>>, usize)>>>`
[INFO] [stdout]    --> src/homogeneous.rs:146:18
[INFO] [stdout]     |
[INFO] [stdout] 146 |             pool.1 -= item.0.size();
[INFO] [stdout]     |                  ^ unknown field
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0609]: no field `1` on type `Result<std::sync::MutexGuard<'_, (VecDeque<homogeneous::Item<V>>, usize)>, PoisonError<std::sync::MutexGuard<'_, (VecDeque<homogeneous::Item<V>>, usize)>>>`
[INFO] [stdout]    --> src/homogeneous.rs:160:11
[INFO] [stdout]     |
[INFO] [stdout] 160 |         p.1 += v.size();
[INFO] [stdout]     |           ^ unknown field
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0609]: no field `0` on type `Result<std::sync::MutexGuard<'_, (VecDeque<homogeneous::Item<V>>, usize)>, PoisonError<std::sync::MutexGuard<'_, (VecDeque<homogeneous::Item<V>>, usize)>>>`
[INFO] [stdout]    --> src/homogeneous.rs:161:11
[INFO] [stdout]     |
[INFO] [stdout] 161 |         p.0.push_back(Item(v, timeout));
[INFO] [stdout]     |           ^ unknown field
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0609]: no field `0` on type `Result<std::sync::MutexGuard<'_, (VecDeque<homogeneous::Item<V>>, usize)>, PoisonError<std::sync::MutexGuard<'_, (VecDeque<homogeneous::Item<V>>, usize)>>>`
[INFO] [stdout]    --> src/homogeneous.rs:166:31
[INFO] [stdout]     |
[INFO] [stdout] 166 |         if let Some(item) = p.0.pop_back() {
[INFO] [stdout]     |                               ^ unknown field
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0609]: no field `1` on type `Result<std::sync::MutexGuard<'_, (VecDeque<homogeneous::Item<V>>, usize)>, PoisonError<std::sync::MutexGuard<'_, (VecDeque<homogeneous::Item<V>>, usize)>>>`
[INFO] [stdout]    --> src/homogeneous.rs:167:15
[INFO] [stdout]     |
[INFO] [stdout] 167 |             p.1 -= item.0.size();
[INFO] [stdout]     |               ^ unknown field
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0609]: no field `0` on type `Result<std::sync::MutexGuard<'_, (VecDeque<homogeneous::Item<V>>, usize)>, PoisonError<std::sync::MutexGuard<'_, (VecDeque<homogeneous::Item<V>>, usize)>>>`
[INFO] [stdout]    --> src/homogeneous.rs:181:26
[INFO] [stdout]     |
[INFO] [stdout] 181 |         for item in pool.0.iter() {
[INFO] [stdout]     |                          ^ unknown field
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0609]: no field `0` on type `Result<std::sync::MutexGuard<'_, (VecDeque<homogeneous::Item<V>>, usize)>, PoisonError<std::sync::MutexGuard<'_, (VecDeque<homogeneous::Item<V>>, usize)>>>`
[INFO] [stdout]    --> src/homogeneous.rs:187:22
[INFO] [stdout]     |
[INFO] [stdout] 187 |         if i >= pool.0.len() {
[INFO] [stdout]     |                      ^ unknown field
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0609]: no field `0` on type `Result<std::sync::MutexGuard<'_, (VecDeque<homogeneous::Item<V>>, usize)>, PoisonError<std::sync::MutexGuard<'_, (VecDeque<homogeneous::Item<V>>, usize)>>>`
[INFO] [stdout]    --> src/homogeneous.rs:190:34
[INFO] [stdout]     |
[INFO] [stdout] 190 |         if let Some(item) = pool.0.swap_remove_front(i) {
[INFO] [stdout]     |                                  ^ unknown field
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0609]: no field `1` on type `Result<std::sync::MutexGuard<'_, (VecDeque<homogeneous::Item<V>>, usize)>, PoisonError<std::sync::MutexGuard<'_, (VecDeque<homogeneous::Item<V>>, usize)>>>`
[INFO] [stdout]    --> src/homogeneous.rs:191:18
[INFO] [stdout]     |
[INFO] [stdout] 191 |             pool.1 -= item.0.size();
[INFO] [stdout]     |                  ^ unknown field
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0609]: no field `0` on type `Result<std::sync::MutexGuard<'_, (VecDeque<homogeneous::Item<V>>, usize)>, PoisonError<std::sync::MutexGuard<'_, (VecDeque<homogeneous::Item<V>>, usize)>>>`
[INFO] [stdout]    --> src/homogeneous.rs:206:21
[INFO] [stdout]     |
[INFO] [stdout] 206 |         while !pool.0.is_empty() {
[INFO] [stdout]     |                     ^ unknown field
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0609]: no field `0` on type `Result<std::sync::MutexGuard<'_, (VecDeque<homogeneous::Item<V>>, usize)>, PoisonError<std::sync::MutexGuard<'_, (VecDeque<homogeneous::Item<V>>, usize)>>>`
[INFO] [stdout]    --> src/homogeneous.rs:207:26
[INFO] [stdout]     |
[INFO] [stdout] 207 |             let r = pool.0.front().unwrap();
[INFO] [stdout]     |                          ^ unknown field
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0609]: no field `0` on type `Result<std::sync::MutexGuard<'_, (VecDeque<homogeneous::Item<V>>, usize)>, PoisonError<std::sync::MutexGuard<'_, (VecDeque<homogeneous::Item<V>>, usize)>>>`
[INFO] [stdout]    --> src/homogeneous.rs:212:26
[INFO] [stdout]     |
[INFO] [stdout] 212 |             let r = pool.0.pop_front().unwrap();
[INFO] [stdout]     |                          ^ unknown field
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stderr] error: could not compile `pi_assets` (lib) due to 54 previous errors
[INFO] [stderr] warning: build failed, waiting for other jobs to finish...
[INFO] [stdout] error[E0609]: no field `1` on type `Result<std::sync::MutexGuard<'_, (VecDeque<homogeneous::Item<V>>, usize)>, PoisonError<std::sync::MutexGuard<'_, (VecDeque<homogeneous::Item<V>>, usize)>>>`
[INFO] [stdout]    --> src/homogeneous.rs:217:18
[INFO] [stdout]     |
[INFO] [stdout] 217 |             pool.1 -= sub;
[INFO] [stdout]     |                  ^ unknown field
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0609]: no field `0` on type `Result<std::sync::MutexGuard<'_, (VecDeque<homogeneous::Item<V>>, usize)>, PoisonError<std::sync::MutexGuard<'_, (VecDeque<homogeneous::Item<V>>, usize)>>>`
[INFO] [stdout]    --> src/homogeneous.rs:229:46
[INFO] [stdout]     |
[INFO] [stdout] 229 |         while size > capacity + sub && !pool.0.is_empty() {
[INFO] [stdout]     |                                              ^ unknown field
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0609]: no field `0` on type `Result<std::sync::MutexGuard<'_, (VecDeque<homogeneous::Item<V>>, usize)>, PoisonError<std::sync::MutexGuard<'_, (VecDeque<homogeneous::Item<V>>, usize)>>>`
[INFO] [stdout]    --> src/homogeneous.rs:230:26
[INFO] [stdout]     |
[INFO] [stdout] 230 |             let r = pool.0.pop_front().unwrap();
[INFO] [stdout]     |                          ^ unknown field
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0609]: no field `1` on type `Result<std::sync::MutexGuard<'_, (VecDeque<homogeneous::Item<V>>, usize)>, PoisonError<std::sync::MutexGuard<'_, (VecDeque<homogeneous::Item<V>>, usize)>>>`
[INFO] [stdout]    --> src/homogeneous.rs:235:18
[INFO] [stdout]     |
[INFO] [stdout] 235 |             pool.1 -= sub;
[INFO] [stdout]     |                  ^ unknown field
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0609]: no field `0` on type `Result<std::sync::MutexGuard<'_, (VecDeque<homogeneous::Item<V>>, usize)>, PoisonError<std::sync::MutexGuard<'_, (VecDeque<homogeneous::Item<V>>, usize)>>>`
[INFO] [stdout]    --> src/homogeneous.rs:245:20
[INFO] [stdout]     |
[INFO] [stdout] 245 |         for item in pool.0.iter() {
[INFO] [stdout]     |                          ^ unknown field
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: aborting due to 53 previous errors
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] Some errors have detailed explanations: E0599, E0609, E0615.
[INFO] [stdout] 
[INFO] [stdout] For more information about an error, try `rustc --explain E0599`.
[INFO] [stdout] 
[INFO] [stderr] error: could not compile `pi_assets` (lib test) due to 54 previous errors
[INFO] running `Command { std: "docker" "inspect" "0a4ab7197e7f3893f852e45994af7bb0d3bab4bb76a3e35b673d9e51d79ce63c", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "rm" "-f" "0a4ab7197e7f3893f852e45994af7bb0d3bab4bb76a3e35b673d9e51d79ce63c", kill_on_drop: false }`
[INFO] [stdout] 0a4ab7197e7f3893f852e45994af7bb0d3bab4bb76a3e35b673d9e51d79ce63c
